Experimentation adding box conversion

.circleci/config.yml

@@ -1,94 +0,0 @@
-version: 2.1
-
-orbs:
-  aws-s3: circleci/aws-s3@2.0.0
-
-commands:
-  zip-source:
-    parameters:
-      target:
-        type: string
-      outputdir:
-        type: string
-    steps:
-      - run:
-          name: "Create Archive"
-          command: |
-            \cp -r ".pluginconfig/<<parameters.target>>/." "./"
-            mkdir -p "<<parameters.outputdir>>/"
-            stashName=`git stash create`;
-            git archive -o "<<parameters.outputdir>>/speckle-unreal-UE<<parameters.target>>.zip" --worktree-attributes --prefix="speckle-unreal/" $stashName
-
-jobs:
-  generate-source-zip:
-    docker:
-      - image: cimg/base:stable
-    parameters:
-      target:
-        type: string
-    steps:
-      - checkout
-      - zip-source:
-            target: <<parameters.target>>
-            outputdir: "output/unreal/<<parameters.target>>"
-      - store_artifacts:
-          path: "output/unreal/<<parameters.target>>"
-          destination: "unreal-marketplace/<<parameters.target>>"
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - "output/unreal/<<parameters.target>>"
-
-  marketplace-deploy:
-    docker:
-      - image: cimg/base:stable
-    steps:
-      - attach_workspace:
-          at: ./
-      - aws-s3/copy:
-          arguments: "--recursive --endpoint=https://$SPACES_REGION.digitaloceanspaces.com --acl public-read"
-          aws-access-key-id: SPACES_KEY
-          aws-region: SPACES_REGION
-          aws-secret-access-key: SPACES_SECRET
-          from: '"output"'
-          to: s3://speckle-releases/installers/
-
-workflows:
-  marketplace-publish:
-    jobs:
-      - generate-source-zip:
-          name: "Generate Source Archive UE4.26"
-          target: "4.26"
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: /^([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?(\/all)?$/
-      - generate-source-zip:
-          name: "Generate Source Archive UE4.27"
-          target: "4.27"
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: /^([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?(\/all)?$/
-      - generate-source-zip:
-          name: "Generate Source Archive UE5.0"
-          target: "5.0"
-          filters:
-            branches:
-              ignore: /.*/
-            tags:
-              only: /^([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?(\/all)?$/
-      - hold:
-          type: approval
-          requires: 
-            - "Generate Source Archive UE4.26"
-            - "Generate Source Archive UE4.27"
-            - "Generate Source Archive UE5.0"
-      - marketplace-deploy:
-          name: "Deploy to marketplace"
-          requires:
-            - hold
-
-          

.gitattributes

@@ -1,4 +0,0 @@
-.gitattributes export-ignore
-.github/* export-ignore
-.circleci/* export-ignore
-.pluginconfig/* export-ignore

.pluginconfig/4.26/SpeckleUnreal.uplugin

@@ -1,42 +0,0 @@
-{
-	"FileVersion": 3,
-	"Version": 1,
-	"VersionName": "2.6.0",
-	"FriendlyName": "Speckle Unreal",
-	"Description": "Speckle is an open source data platform for Architecture, Engineering, and Construction. It has been open sourced under the MIT license, is customizable, and available in the cloud or via a self-hosted server. It allows users to exchange data between various AEC modelling and content creation platforms.",
-	"Category": "AEC",
-	"CreatedBy": "Speckle",
-	"CreatedByURL": "https://speckle.systems/",
-	"DocsURL": "https://github.com/specklesystems/speckle-unreal",
-	"MarketplaceURL": "com.epicgames.launcher://ue/marketplace/product/98770ce9d4f143de8dd7882a707a6f81",
-	"SupportURL": "https://speckle.community/",
-	"CanContainContent": true,
-	"IsBetaVersion": true,
-	"IsExperimentalVersion": false,
-	"Installed": false,
-	"EngineVersion": "4.26",
-	"Modules": [
-		{
-			"Name": "SpeckleUnreal",
-			"Type": "Runtime",
-			"LoadingPhase": "Default",
-			"WhitelistPlatforms": [ "Win64", "Linux", "Mac" ]
-		},
-		{
-			"Name": "SpeckleUnrealEditor",
-			"Type": "Editor",
-			"LoadingPhase": "PostEngineInit",
-			"WhitelistPlatforms": [ "Win64", "Linux", "Mac" ]
-		}
-	],
-	"Plugins": [
-		{
-			"Name": "ProceduralMeshComponent",
-			"Enabled": true
-		},
-		{
-			"Name": "LidarPointCloud",
-			"Enabled": true
-		}
-	]
-}

.pluginconfig/4.27/SpeckleUnreal.uplugin

@@ -1,42 +0,0 @@
-{
-	"FileVersion": 3,
-	"Version": 1,
-	"VersionName": "2.6.0",
-	"FriendlyName": "Speckle Unreal",
-	"Description": "Speckle is an open source data platform for Architecture, Engineering, and Construction. It has been open sourced under the MIT license, is customizable, and available in the cloud or via a self-hosted server. It allows users to exchange data between various AEC modelling and content creation platforms.",
-	"Category": "AEC",
-	"CreatedBy": "Speckle",
-	"CreatedByURL": "https://speckle.systems/",
-	"DocsURL": "https://github.com/specklesystems/speckle-unreal",
-	"MarketplaceURL": "com.epicgames.launcher://ue/marketplace/product/98770ce9d4f143de8dd7882a707a6f81",
-	"SupportURL": "https://speckle.community/",
-	"CanContainContent": true,
-	"IsBetaVersion": true,
-	"IsExperimentalVersion": false,
-	"Installed": false,
-	"EngineVersion": "4.27",
-	"Modules": [
-		{
-			"Name": "SpeckleUnreal",
-			"Type": "Runtime",
-			"LoadingPhase": "Default",
-			"WhitelistPlatforms": [ "Win64", "Linux", "Mac" ]
-		},
-		{
-			"Name": "SpeckleUnrealEditor",
-			"Type": "Editor",
-			"LoadingPhase": "PostEngineInit",
-			"WhitelistPlatforms": [ "Win64", "Linux", "Mac" ]
-		}
-	],
-	"Plugins": [
-		{
-			"Name": "ProceduralMeshComponent",
-			"Enabled": true
-		},
-		{
-			"Name": "LidarPointCloud",
-			"Enabled": true
-		}
-	]
-}

.pluginconfig/5.0/SpeckleUnreal.uplugin

@@ -1,42 +0,0 @@
-{
-	"FileVersion": 3,
-	"Version": 1,
-	"VersionName": "2.6.0",
-	"FriendlyName": "Speckle Unreal",
-	"Description": "Speckle is an open source data platform for Architecture, Engineering, and Construction. It has been open sourced under the MIT license, is customizable, and available in the cloud or via a self-hosted server. It allows users to exchange data between various AEC modelling and content creation platforms.",
-	"Category": "AEC",
-	"CreatedBy": "Speckle",
-	"CreatedByURL": "https://speckle.systems/",
-	"DocsURL": "https://github.com/specklesystems/speckle-unreal",
-	"MarketplaceURL": "com.epicgames.launcher://ue/marketplace/product/98770ce9d4f143de8dd7882a707a6f81",
-	"SupportURL": "https://speckle.community/",
-	"CanContainContent": true,
-	"IsBetaVersion": true,
-	"IsExperimentalVersion": false,
-	"Installed": false,
-	"EngineVersion": "5.0",
-	"Modules": [
-		{
-			"Name": "SpeckleUnreal",
-			"Type": "Runtime",
-			"LoadingPhase": "Default",
-			"WhitelistPlatforms": [ "Win64", "Linux", "Mac" ]
-		},
-		{
-			"Name": "SpeckleUnrealEditor",
-			"Type": "Editor",
-			"LoadingPhase": "PostEngineInit",
-			"WhitelistPlatforms": [ "Win64", "Linux", "Mac" ]
-		}
-	],
-	"Plugins": [
-		{
-			"Name": "ProceduralMeshComponent",
-			"Enabled": true
-		},
-		{
-			"Name": "LidarPointCloud",
-			"Enabled": true
-		}
-	]
-}

Source/SpeckleUnreal/Private/API/ClientAPI.cpp

@@ -1,18 +1,220 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "API/ClientAPI.h"
+#include "API/ClientAPI.h"
 
 #include "HttpModule.h"
-#include "JsonObjectConverter.h"
 #include "Interfaces/IHttpResponse.h"
 #include "LogSpeckle.h"
 #include "Mixpanel.h"
+#include "Objects/HighLevel/SpeckleBranch.h"
+#include "Objects/HighLevel/SpeckleCommit.h"
+#include "Objects/HighLevel/SpeckleGlobals.h"
+#include "Objects/HighLevel/SpeckleUser.h"
+#include "Transports/Transport.h"
 
-void FClientAPI::MakeGraphQLRequest(const FString& ServerUrl, const FString& AuthToken,
-	const FString& ResponsePropertyName,
-	const FString& PostPayload, const FString& RequestLogName,
-	const FAPIResponceDelegate OnCompleteAction, const FErrorDelegate OnErrorAction)
+
+void FClientAPI::StreamsGet(const FString& ServerUrl, const FString& AuthToken,
+	const int Limit,
+	const FFetchStreamDelegate OnCompleteAction, const FErrorDelegate OnErrorAction)
 {
+	const FString RequestLogName = FString(__FUNCTION__);
+	
+	const FString PostPayload =
+		"{\"query\": \"query{user {streams(limit:" + FString::FromInt(Limit) + ") {totalCount items {id name description updatedAt createdAt isPublic role  collaborators{id name role company avatar}}}}}\"}";
+	
+	auto OnError = [=](const FString& Message) mutable 
+	{
+		ensureAlwaysMsgf(OnErrorAction.ExecuteIfBound(Message), TEXT("%s: Unhandled error - %s"), *RequestLogName , *Message);
+	};
+	
+	auto ResponseHandler = [=](FHttpRequestPtr, FHttpResponsePtr Response, bool bWasSuccessful) mutable 
+	{
+		if(CheckRequestFailed(bWasSuccessful, Response, RequestLogName, OnError)) return;
+		
+		TSharedPtr<FJsonObject> Obj;
+		if(!GetResponseAsJSON(Response, RequestLogName, Obj, OnError)) return;
+	
+		TArray<TSharedPtr<FJsonValue>> StreamsArrJSON = Obj->GetObjectField(TEXT("data"))
+																   ->GetObjectField(TEXT("user"))
+																	  ->GetObjectField(TEXT("streams"))
+																		   ->GetArrayField(TEXT("items"));
+	
+		TArray<FSpeckleStream> Streams;
+		Streams.Reserve(StreamsArrJSON.Num());
+	
+		for (const TSharedPtr<FJsonValue> v : StreamsArrJSON)
+		{
+			FSpeckleStream Stream = FSpeckleStream(v);
+			Streams.Add(Stream);
+		}
+		
+		UE_LOG(LogSpeckle, Log, TEXT("Operation %s completed successfully. Fetched %d items"), *RequestLogName, Streams.Num());
+		ensureAlwaysMsgf(OnCompleteAction.ExecuteIfBound(Streams), TEXT("%s: Complete handler was not bound properly"), *RequestLogName);
+	};
+	
+	
+	const FHttpRequestRef Request = CreateGraphQLRequest(ServerUrl, AuthToken, PostPayload);
+	Request->OnProcessRequestComplete().BindLambda(ResponseHandler);
+	
+	SendGraphQLRequest(Request, RequestLogName, OnError);
+}
+
+void FClientAPI::StreamGetBranches(
+	const FString& ServerUrl, const FString& AuthToken,
+	const FString& StreamId, const int32 Limit,
+	const FFetchBranchDelegate OnCompleteAction, const FErrorDelegate OnErrorAction)
+{
+	const FString RequestLogName = FString(__FUNCTION__);
+	
+	//TODO limit
+	FString PostPayload = "{\"query\": \"query{ stream (id: \\\"" +
+			StreamId + "\\\"){id name branches(limit : " + FString::FromInt(Limit) + ") {totalCount cursor items{ id name description}}}}\"}";
+
+	// The above can be extended with author information 
+	//query{stream(id:"a18f8c8569"){id name branches{totalCount items{id name description author{id, name, email, commits{cursor}}}}}}
+	
+	auto OnError = [=](const FString& Message) mutable 
+	{
+		ensureAlwaysMsgf(OnErrorAction.ExecuteIfBound(Message), TEXT("%s: Unhandled error - %s"), *RequestLogName , *Message);
+	};
+	
+	auto ResponseHandler = [=](FHttpRequestPtr, FHttpResponsePtr Response, bool bWasSuccessful) mutable 
+	{
+		if(CheckRequestFailed(bWasSuccessful, Response, RequestLogName, OnError)) return;
+		
+		TSharedPtr<FJsonObject> Obj;
+		if(!GetResponseAsJSON(Response, RequestLogName, Obj, OnError)) return;
+		
+		TArray<TSharedPtr<FJsonValue>> BranchesArrJSON = Obj->GetObjectField(TEXT("data"))
+																	->GetObjectField(TEXT("stream"))
+																		->GetObjectField(TEXT("branches"))
+																				->GetArrayField(TEXT("items"));
+		TArray<FSpeckleBranch> Branches;
+		Branches.Reserve(BranchesArrJSON.Num());
+	
+		for (const TSharedPtr<FJsonValue>& v : BranchesArrJSON)
+		{
+			const TSharedPtr<FJsonObject>* BranchObj;
+			if(ensureAlways(v->TryGetObject(BranchObj)))
+			{
+				FSpeckleBranch Branch = FSpeckleBranch(*BranchObj);
+				Branches.Add(Branch);
+			}
+		}
+		
+		UE_LOG(LogSpeckle, Log, TEXT("Operation %s completed successfully. Fetched %d items"), *RequestLogName, Branches.Num());
+		ensureAlwaysMsgf(OnCompleteAction.ExecuteIfBound(Branches), TEXT("%s: Complete handler was not bound properly"), *RequestLogName);
+	};
+	
+	
+	const FHttpRequestRef Request = CreateGraphQLRequest(ServerUrl, AuthToken, PostPayload);
+	Request->OnProcessRequestComplete().BindLambda(ResponseHandler);
+	
+	SendGraphQLRequest(Request, RequestLogName, OnError);
+}
+
+
+void FClientAPI::StreamGetCommits(const FString& ServerUrl, const FString& AuthToken,
+	const FString& StreamId, const FString& BranchName, const int32 Limit,
+	const FFetchCommitDelegate OnCompleteAction, const FErrorDelegate OnErrorAction)
+{
+	const FString RequestLogName = FString(__FUNCTION__);
+	
+	FString PostPayload = "{\"query\": \"query{stream (id: \\\"" + StreamId +
+		"\\\"){id name createdAt updatedAt "
+					+ "branch(name: \\\"" + BranchName + "\\\" ){id name description author{name id email} " +
+					"commits(limit: " + FString::FromInt(Limit) + "){totalCount items {id referencedObject sourceApplication totalChildrenCount " +
+					"branchName parents authorName authorId message createdAt commentCount}}}}}\"}"; // authorAvatar 
+	
+	auto OnError = [=](const FString& Message) mutable 
+	{
+		ensureAlwaysMsgf(OnErrorAction.ExecuteIfBound(Message), TEXT("%s: Unhandled error - %s"), *RequestLogName , *Message);
+	};
+	
+	auto ResponseHandler = [=](FHttpRequestPtr, FHttpResponsePtr Response, bool bWasSuccessful) mutable 
+	{
+		if(CheckRequestFailed(bWasSuccessful, Response, RequestLogName, OnError)) return;
+		
+		TSharedPtr<FJsonObject> Obj;
+		if(!GetResponseAsJSON(Response, RequestLogName, Obj, OnError)) return;
+		
+		TArray<TSharedPtr<FJsonValue>> CommitsArrJSON = Obj->GetObjectField(TEXT("data"))
+															 ->GetObjectField(TEXT("stream"))
+															   ->GetObjectField(TEXT("branch"))
+																 ->GetObjectField(TEXT("commits"))
+																   ->GetArrayField(TEXT("items"));
+	
+		TArray<FSpeckleCommit> ArrayOfCommits;
+		ArrayOfCommits.Reserve(CommitsArrJSON.Num());
+	
+		for (const TSharedPtr<FJsonValue> v : CommitsArrJSON)
+		{
+			FSpeckleCommit Commit = FSpeckleCommit(v);
+			ArrayOfCommits.Add( Commit );
+		}
+
+		UE_LOG(LogSpeckle, Log, TEXT("Operation %s completed successfully. Fetched %d items"), *RequestLogName, ArrayOfCommits.Num());
+		ensureAlwaysMsgf(OnCompleteAction.ExecuteIfBound(ArrayOfCommits), TEXT("%s: Complete handler was not bound properly"), *RequestLogName);
+	};
+	
+	
+	const FHttpRequestRef Request = CreateGraphQLRequest(ServerUrl, AuthToken, PostPayload);
+	Request->OnProcessRequestComplete().BindLambda(ResponseHandler);
+	
+	SendGraphQLRequest(Request, RequestLogName, OnError);
+}
+
+
+void FClientAPI::FetchGlobals(const FString& ServerUrl, const FString& AuthToken,
+	const FString& StreamId, const FString& ReferencedObjectId,
+    const FFetchGlobalsDelegate OnCompleteAction, const FErrorDelegate OnErrorAction)
+{
+	const FString RequestLogName = FString(__FUNCTION__);
+	
+	FString PostPayload = "{\"query\": \"query{stream (id:\\\"" + StreamId +
+							 "\\\"){id name description updatedAt createdAt role isPublic object(id:\\\"" +
+								ReferencedObjectId +
+							    	"\\\"){id data}}}\"}";
+	
+	auto OnError = [=](const FString& Message) mutable 
+	{
+		ensureAlwaysMsgf(OnErrorAction.ExecuteIfBound(Message), TEXT("%s: Unhandled error - %s"), *RequestLogName , *Message);
+	};
+	
+	auto ResponseHandler = [=](FHttpRequestPtr, FHttpResponsePtr Response, bool bWasSuccessful) mutable 
+	{
+		if(CheckRequestFailed(bWasSuccessful, Response, RequestLogName, OnError)) return;
+		
+		TSharedPtr<FJsonObject> Obj;
+		if(!GetResponseAsJSON(Response, RequestLogName, Obj, OnError)) return;
+		
+		TSharedPtr<FJsonObject> GlobalsJSONObject = Obj->GetObjectField(TEXT("data"))
+															->GetObjectField(TEXT("stream"))
+																->GetObjectField(TEXT("object"))
+																	->GetObjectField(TEXT("data"));
+
+
+		
+		
+		FSpeckleGlobals Globals = FSpeckleGlobals(GlobalsJSONObject);
+		
+		UE_LOG(LogSpeckle, Log, TEXT("Operation %s completed successfully"), *RequestLogName);
+		ensureAlwaysMsgf(OnCompleteAction.ExecuteIfBound(Globals), TEXT("%s: Complete handler was not bound properly"), *RequestLogName);
+	};
+	
+	
+	const FHttpRequestRef Request = CreateGraphQLRequest(ServerUrl, AuthToken, PostPayload);
+	Request->OnProcessRequestComplete().BindLambda(ResponseHandler);
+	
+	SendGraphQLRequest(Request, RequestLogName, OnError);
+}
+
+void FClientAPI::FetchUserData(const FString& ServerUrl, const FString& AuthToken,
+    const FFetchUserDelegate OnCompleteAction, const FErrorDelegate OnErrorAction)
+{
+	const FString RequestLogName = FString(__FUNCTION__);
+	
+	const FString PostPayload =
+		"{\"query\": \"query{user{id name email company role suuid bio profiles avatar}}\"}"; 
+	
 	
 	auto OnError = [=](const FString& Message) mutable 
 	{
@@ -26,74 +228,24 @@ void FClientAPI::MakeGraphQLRequest(const FString& ServerUrl, const FString& Aut
 		
 		TSharedPtr<FJsonObject> Obj;
 		if(!GetResponseAsJSON(Response, RequestLogName, Obj, OnError)) return;
-
-		const TSharedPtr<FJsonObject>* DataObjectPtr;
-		if(!Obj->TryGetObjectField("data", DataObjectPtr))
-		{
-			OnError(TEXT("%s responce was invalid, expected to find a \"data\" property in response"));
-			return;
-		}
-		const TSharedPtr<FJsonObject> DataObject = *DataObjectPtr;
 		
-		const TSharedPtr<FJsonObject>* RequestedJson;
-		if(!DataObject->TryGetObjectField(ResponsePropertyName, RequestedJson))
-		{
-			//Requested property has a null or non-object value
-			if(DataObject->HasField(ResponsePropertyName))
-			{
-				FString Message = FString::Printf(TEXT("%s: Response data contained the requested property \"%s\", but the value was null was or not an object."),
-				*RequestLogName, *ResponsePropertyName);
-				OnError(Message);
-				return;
-			}
-
-			//Requested property was missing
-			TArray<FString> Options;
-			Options.Reserve(DataObject->Values.Num());
-			for(const auto& Properties : DataObject->Values)
-			{
-				Options.Add(FString::Printf(TEXT("\"%s\" "), *Properties.Key));
-			}
-			
-			FString Message = FString::Printf(TEXT("%s: Could not find the requested property name \"%s\" in responce data.\n Got { %s} instead."),
-				*RequestLogName, *ResponsePropertyName, *FString::Join(Options, TEXT(", ")));
-			OnError(Message);
-			return;
-		}
+		TSharedPtr<FJsonObject> UserJSONObject = Obj->GetObjectField(TEXT("data"))
+													    ->GetObjectField(TEXT("user"));
 		
-		FString OutputString;
-		const TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
-		ensureAlways(FJsonSerializer::Serialize(RequestedJson->ToSharedRef(), Writer));
-
-		// Commented out, deserialisation done by caller
-		//void* DeserializedData;
-		//FSpeckleUser DeserializedData = FSpeckleUser( UserJSONObject );
-		// if(!FJsonObjectConverter::JsonObjectToUStruct(*RequestedJson, OutStructType::StaticStruct(), &DeserializedData, 0, 0))
-		// {
-		// 	OnError("Failed to deserialize user object");
-		// 	return;
-		// }
+		FSpeckleUser MyUserData = FSpeckleUser( UserJSONObject );
 		
 		UE_LOG(LogSpeckle, Log, TEXT("Operation %s completed successfully"), *RequestLogName);
-		ensureAlwaysMsgf(OnCompleteAction.ExecuteIfBound(OutputString), TEXT("%s: Complete handler was not bound properly"), *RequestLogName);
+		ensureAlwaysMsgf(OnCompleteAction.ExecuteIfBound(MyUserData), TEXT("%s: Complete handler was not bound properly"), *RequestLogName);
 	};
 
-	const FHttpRequestRef Request = CreatePostRequest(ServerUrl, AuthToken, PostPayload);
+	const FHttpRequestRef Request = CreateGraphQLRequest(ServerUrl, AuthToken, PostPayload);
 	Request->OnProcessRequestComplete().BindLambda(ResponseHandler);
 	
-	if(Request->ProcessRequest())
-	{
-		UE_LOG(LogSpeckle, Log, TEXT("POST Request %s to %s was sent, awaiting response"), *RequestLogName, *Request->GetURL() );
-	}
-	else
-	{
-		UE_LOG(LogSpeckle, Warning, TEXT("POST Request %s to %s failed to send"), *RequestLogName, *Request->GetURL() );
-	}
-	
-	FAnalytics::TrackEvent(Request->GetURL(), "NodeRun", TMap<FString, FString> { {"name", __FUNCTION__}});
+	SendGraphQLRequest(Request, RequestLogName, OnError);
 }
 
 
+
 bool FClientAPI::GetResponseAsJSON(const FHttpResponsePtr Response, const FString& RequestLogName, TSharedPtr<FJsonObject>& OutObject, const TFunctionRef<void(const FString& Message)> OnErrorAction)
 {
 
@@ -121,7 +273,7 @@ bool FClientAPI::GetResponseAsJSON(const FHttpResponsePtr Response, const FStrin
 	return true;
 }
 
-FHttpRequestRef FClientAPI::CreatePostRequest(const FString& ServerUrl, const FString AuthToken, const FString& PostPayload, const FString& Encoding)
+FHttpRequestRef FClientAPI::CreateGraphQLRequest(const FString& ServerUrl, const FString AuthToken, const FString& PostPayload, const FString& Encoding)
 {
 	FHttpRequestRef Request = FHttpModule::Get().CreateRequest();
 
@@ -135,6 +287,26 @@ FHttpRequestRef FClientAPI::CreatePostRequest(const FString& ServerUrl, const FS
 	return Request;
 }
 
+bool FClientAPI::SendGraphQLRequest(const FHttpRequestRef Request, const FString& RequestName,
+ const TFunctionRef<void(const FString& Message)> OnErrorAction)
+{
+	const bool RequestSent = Request->ProcessRequest();
+
+	if(!RequestSent)
+	{
+		const FString Message = FString::Printf(TEXT("Request \"%s\" at \"%s\" failed: \nHTTP request failed to start"),
+					*RequestName, *Request->GetURL());
+		
+		OnErrorAction(Message);
+	}
+	else
+	{
+		UE_LOG(LogSpeckle, Log, TEXT("POST Request %s to %s was sent, awaiting response"), *RequestName, *Request->GetURL() );
+		FAnalytics::TrackEvent("unknown", Request->GetURL(), "NodeRun", TMap<FString, FString> { {"name", RequestName }});
+	}
+	
+	return RequestSent;
+}
 
 
 bool FClientAPI::CheckRequestFailed(bool bWasSuccessful, FHttpResponsePtr Response,  const FString& RequestLogName, const TFunctionRef<void(const FString& Message)> OnErrorAction)
@@ -152,8 +324,8 @@ bool FClientAPI::CheckRequestFailed(bool bWasSuccessful, FHttpResponsePtr Respon
 	const int32 ResponseCode = Response->GetResponseCode();
 	if (ResponseCode != 200)
 	{
-		FString Message = FString::Printf(TEXT("Request \"%s\" to \"%s\" failed with HTTP response %d - %s"),
-												*RequestLogName, *Response->GetURL(), ResponseCode, *Response->GetContentAsString());
+		FString Message = FString::Printf(TEXT("Request \"%s\" to \"%s\" failed with HTTP response %d"),
+												*RequestLogName, *Response->GetURL(), ResponseCode);
 		OnErrorAction(Message);
 		return true;
 	}
@@ -169,7 +341,7 @@ bool FClientAPI::CheckForOperationErrors(const TSharedPtr<FJsonObject> GraphQLRe
 	
 	bool WasError = false;
 	const TArray<TSharedPtr<FJsonValue>>* Errors;
-	if(GraphQLResponse->TryGetArrayField(TEXT("errors"), Errors))
+	if(GraphQLResponse->TryGetArrayField(TEXT("Errors"), Errors))
 	{
 		for(const TSharedPtr<FJsonValue>& e : *Errors)
 		{

Source/SpeckleUnreal/Private/API/Operations/ReceiveBranchesOperation.cpp

@@ -0,0 +1,73 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "API/Operations/ReceiveBranchesOperation.h"
+
+#include "Mixpanel.h"
+#include "LogSpeckle.h"
+#include "API/ClientAPI.h"
+
+
+UReceiveBranchesOperation* UReceiveBranchesOperation::ReceiveBranchesOperation(UObject* WorldContextObject,
+                                                                               const FString& ServerUrl, const FString& AuthToken,
+                                                                               const FString& StreamId, int32 Limit)
+{
+	FString ObjectId = "Streams";
+	
+    UReceiveBranchesOperation* Node = NewObject<UReceiveBranchesOperation>();
+    Node->StreamId = StreamId.TrimEnd();
+    Node->ServerUrl = ServerUrl.TrimEnd();
+	while(Node->ServerUrl.RemoveFromEnd("/")) { }
+	Node->AuthToken = AuthToken.TrimEnd();
+	Node->Limit = Limit;
+
+	Node->RegisterWithGameInstance(WorldContextObject);
+    return Node;
+}
+
+void UReceiveBranchesOperation::Activate()
+{
+	FAnalytics::TrackEvent("unknown",
+		ServerUrl, "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }});
+	
+	Request();
+}
+
+void UReceiveBranchesOperation::Request()
+{
+	ensureAlways(Limit > 0);
+
+	FFetchBranchDelegate CompleteDelegate;
+	CompleteDelegate.BindUObject(this, &UReceiveBranchesOperation::HandleReceive);
+	
+	FErrorDelegate ErrorDelegate;
+	ErrorDelegate.BindUObject(this, &UReceiveBranchesOperation::HandleError);
+
+	FClientAPI::StreamGetBranches(ServerUrl, AuthToken, StreamId, Limit, CompleteDelegate, ErrorDelegate);
+}
+
+void UReceiveBranchesOperation::HandleReceive(const TArray<FSpeckleBranch>& Branches)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Log, TEXT("%s to %s Succeeded"), *StaticClass()->GetName(), *ServerUrl);
+	
+	
+	FEditorScriptExecutionGuard ScriptGuard;
+	OnReceiveSuccessfully.Broadcast(Branches, "");		
+	
+	SetReadyToDestroy();
+}
+
+void UReceiveBranchesOperation::HandleError(const FString& Message)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Warning, TEXT("%s failed - %s"), *StaticClass()->GetName(), *Message);
+
+	FEditorScriptExecutionGuard ScriptGuard;
+
+	const TArray<FSpeckleBranch> EmptyList;
+	OnError.Broadcast(EmptyList, Message);
+	
+	SetReadyToDestroy();
+}
+

Source/SpeckleUnreal/Private/API/Operations/ReceiveCommitsOperation.cpp

@@ -0,0 +1,72 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "API/Operations/ReceiveCommitsOperation.h"
+
+#include "Mixpanel.h"
+#include "LogSpeckle.h"
+#include "API/ClientAPI.h"
+
+
+// ReceiveOperation
+UReceiveCommitsOperation* UReceiveCommitsOperation::ReceiveCommitsOperation(UObject* WorldContextObject,
+	const FString& ServerUrl, const FString& AuthToken,
+	const FString& StreamId, const FString& BranchName, const int32 Limit)
+{
+    UReceiveCommitsOperation* Node = NewObject<UReceiveCommitsOperation>();
+    Node->ServerUrl = ServerUrl.TrimEnd();
+	while(Node->ServerUrl.RemoveFromEnd("/")) { }
+	Node->AuthToken = AuthToken.TrimEnd();
+    Node->StreamId = StreamId.TrimEnd();
+	Node->BranchName = BranchName;
+    Node->Limit = Limit;
+	Node->RegisterWithGameInstance(WorldContextObject);
+    return Node;
+}
+
+// Activate
+void UReceiveCommitsOperation::Activate()
+{
+	FAnalytics::TrackEvent("unknown", ServerUrl,
+		 "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }});
+	
+	Request();
+}
+
+void UReceiveCommitsOperation::Request()
+{
+	ensureAlways(Limit > 0);
+
+	FFetchCommitDelegate CompleteDelegate;
+	CompleteDelegate.BindUObject(this, &UReceiveCommitsOperation::HandleReceive);
+
+	FErrorDelegate ErrorDelegate;
+	ErrorDelegate.BindUObject(this, &UReceiveCommitsOperation::HandleError);
+
+	FClientAPI::StreamGetCommits(ServerUrl, AuthToken, StreamId, BranchName, Limit, CompleteDelegate, ErrorDelegate);
+}
+
+void UReceiveCommitsOperation::HandleReceive(const TArray<FSpeckleCommit>& Commits)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Log, TEXT("%s to %s Succeeded"), *StaticClass()->GetName(), *ServerUrl);
+	FEditorScriptExecutionGuard ScriptGuard;
+	
+	OnReceiveSuccessfully.Broadcast(Commits, "");
+	
+	SetReadyToDestroy();
+}
+
+void UReceiveCommitsOperation::HandleError(const FString& Message)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Warning, TEXT("%s failed - %s"), *StaticClass()->GetName(), *Message);
+	
+	FEditorScriptExecutionGuard ScriptGuard;
+	
+	const TArray<FSpeckleCommit> EmptyList;
+	OnError.Broadcast(EmptyList, Message);
+	
+	SetReadyToDestroy();
+}
+

Source/SpeckleUnreal/Private/API/Operations/ReceiveGlobalsOperation.cpp

@@ -0,0 +1,66 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "API/Operations/ReceiveGlobalsOperation.h"
+
+#include "Mixpanel.h"
+#include "LogSpeckle.h"
+#include "API/ClientAPI.h"
+
+
+UReceiveGlobalsOperation* UReceiveGlobalsOperation::ReceiveGlobalsOperation(UObject* WorldContextObject,
+                                                                            const FString& ServerUrl, const FString& AuthToken,
+                                                                            const FString& StreamId, const FString& ReferencedObjectId)
+{
+    UReceiveGlobalsOperation* Node = NewObject<UReceiveGlobalsOperation>();
+    Node->ServerUrl = ServerUrl.TrimEnd();
+	while(Node->ServerUrl.RemoveFromEnd("/")) { }
+	Node->AuthToken = AuthToken.TrimEnd();;
+    Node->StreamId = StreamId.TrimEnd();;
+    Node->ReferencedObjectId = ReferencedObjectId;
+
+	Node->RegisterWithGameInstance(WorldContextObject);
+    return Node;
+}
+
+void UReceiveGlobalsOperation::Activate()
+{
+	FAnalytics::TrackEvent("unknown",
+		ServerUrl, "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }});
+	
+	Request();
+}
+
+void UReceiveGlobalsOperation::Request()
+{
+	FFetchGlobalsDelegate CompleteDelegate;
+	CompleteDelegate.BindUObject(this, &UReceiveGlobalsOperation::HandleReceive);
+
+	FErrorDelegate ErrorDelegate;
+	ErrorDelegate.BindUObject(this, &UReceiveGlobalsOperation::HandleError);
+	
+	FClientAPI::FetchGlobals(ServerUrl, AuthToken, StreamId, ReferencedObjectId, CompleteDelegate, ErrorDelegate);
+}
+
+
+
+void UReceiveGlobalsOperation::HandleReceive(const FSpeckleGlobals& Object)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Log, TEXT("%s to %s Succeeded"), *StaticClass()->GetName(), *ServerUrl);
+	FEditorScriptExecutionGuard ScriptGuard;
+	OnReceiveSuccessfully.Broadcast(Object, "");		
+	
+	SetReadyToDestroy();
+}
+
+void UReceiveGlobalsOperation::HandleError(const FString& Message)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Warning, TEXT("%s failed - %s"), *StaticClass()->GetName(), *Message);
+	
+	FEditorScriptExecutionGuard ScriptGuard;
+	const FSpeckleGlobals BlankGlobals;
+	OnError.Broadcast(BlankGlobals, Message);
+	SetReadyToDestroy();
+}

Source/SpeckleUnreal/Private/API/Operations/ReceiveMyUserDataOperation.cpp

@@ -0,0 +1,64 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "API/Operations/ReceiveMyUserDataOperation.h"
+
+#include "Mixpanel.h"
+#include "LogSpeckle.h"
+#include "API/ClientAPI.h"
+
+
+UReceiveMyUserDataOperation* UReceiveMyUserDataOperation::ReceiveMyUserDataOperation(
+	UObject* WorldContextObject, const FString& ServerUrl, const FString& AuthToken)
+{
+    UReceiveMyUserDataOperation* Node = NewObject<UReceiveMyUserDataOperation>();
+    Node->ServerUrl = ServerUrl.TrimEnd();;
+	while(Node->ServerUrl.RemoveFromEnd("/")) { }
+    Node->AuthToken = AuthToken.TrimEnd();;
+
+	Node->RegisterWithGameInstance(WorldContextObject);
+    return Node;
+}
+
+void UReceiveMyUserDataOperation::Activate()
+{
+	FAnalytics::TrackEvent("unknown",
+		ServerUrl, "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }});
+
+	Request();
+}
+
+
+void UReceiveMyUserDataOperation::Request()
+{
+	FFetchUserDelegate CompleteDelegate;
+	CompleteDelegate.BindUObject(this, &UReceiveMyUserDataOperation::HandleReceive);
+
+	FErrorDelegate ErrorDelegate;
+	ErrorDelegate.BindUObject(this, &UReceiveMyUserDataOperation::HandleError);
+	
+	FClientAPI::FetchUserData(ServerUrl, AuthToken, CompleteDelegate, ErrorDelegate);
+}
+
+
+
+void UReceiveMyUserDataOperation::HandleReceive(const FSpeckleUser& Object)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Log, TEXT("%s to %s Succeeded"), *StaticClass()->GetName(), *ServerUrl);
+	FEditorScriptExecutionGuard ScriptGuard;
+	OnReceiveSuccessfully.Broadcast(Object, "");		
+	
+	SetReadyToDestroy();
+}
+
+void UReceiveMyUserDataOperation::HandleError(const FString& Message)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Warning, TEXT("%s failed - %s"), *StaticClass()->GetName(), *Message);
+	
+	FEditorScriptExecutionGuard ScriptGuard;
+	const FSpeckleUser BlankUser;
+	OnError.Broadcast(BlankUser, Message);
+	SetReadyToDestroy();
+}

Source/SpeckleUnreal/Private/API/Operations/ReceiveOperation.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "API/Operations/ReceiveOperation.h"
 
@@ -9,6 +10,7 @@
 #include "Mixpanel.h"
 
 
+// ReceiveOperation
 UReceiveOperation* UReceiveOperation::ReceiveOperation(UObject* WorldContextObject,
 													   const FString& ObjectId,
 							                           TScriptInterface<ITransport> RemoteTransport,
@@ -23,10 +25,13 @@ UReceiveOperation* UReceiveOperation::ReceiveOperation(UObject* WorldContextObje
     return Node;
 }
 
+// Activate
 void UReceiveOperation::Activate()
 {
-	FAnalytics::TrackEvent("unknown", "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName()} });
+	FAnalytics::TrackEvent("unknown",
+		"unknown", "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }});
 
+	//Async(EAsyncExecution::Thread, [this]{Receive();});
 	Receive();
 }
 

Source/SpeckleUnreal/Private/API/Operations/ReceiveStreamsOperation.cpp

@@ -0,0 +1,69 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "API/Operations/ReceiveStreamsOperation.h"
+
+#include "Mixpanel.h"
+#include "LogSpeckle.h"
+#include "API/ClientAPI.h"
+
+
+UReceiveStreamsOperation* UReceiveStreamsOperation::ReceiveStreamsOperation(UObject* WorldContextObject,
+                                                                            const FString& ServerUrl,
+                                                                            const FString& AuthToken,
+                                                                            const int32 Limit)
+{
+	FString ObjectId = "Streams";
+	
+    UReceiveStreamsOperation* Node = NewObject<UReceiveStreamsOperation>();
+    Node->ServerUrl = ServerUrl.TrimEnd();;
+	Node->AuthToken = AuthToken.TrimEnd();;
+	Node->Limit = Limit;
+
+	Node->RegisterWithGameInstance(WorldContextObject);
+    return Node;
+}
+
+void UReceiveStreamsOperation::Activate()
+{
+	FAnalytics::TrackEvent("unknown",
+		ServerUrl, "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }});
+
+	Request();
+}
+
+void UReceiveStreamsOperation::Request()
+{
+	FFetchStreamDelegate CompleteDelegate;
+	CompleteDelegate.BindUObject(this, &UReceiveStreamsOperation::HandleReceive);
+
+	FErrorDelegate ErrorDelegate;
+	ErrorDelegate.BindUObject(this, &UReceiveStreamsOperation::HandleError);
+
+	FClientAPI::StreamsGet(ServerUrl, AuthToken, Limit, CompleteDelegate, ErrorDelegate);
+}
+
+void UReceiveStreamsOperation::HandleReceive(const TArray<FSpeckleStream>& Streams)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Log, TEXT("%s to %s Succeeded"), *StaticClass()->GetName(), *ServerUrl);
+	
+	FEditorScriptExecutionGuard ScriptGuard;
+	OnReceiveSuccessfully.Broadcast(Streams, "");		
+	
+	SetReadyToDestroy();
+}
+
+void UReceiveStreamsOperation::HandleError(const FString& Message)
+{
+	check(IsInGameThread());
+	UE_LOG(LogSpeckle, Warning, TEXT("%s failed - %s"), *StaticClass()->GetName(), *Message);
+	
+	FEditorScriptExecutionGuard ScriptGuard;
+	
+	const TArray<FSpeckleStream> EmptyList;
+	OnError.Broadcast(EmptyList, Message);
+		
+	SetReadyToDestroy();
+}
+

Source/SpeckleUnreal/Private/API/Operations/SpeckleStreamAPIOperation.cpp

@@ -1,69 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "API/Operations/SpeckleStreamAPIOperation.h"
-
-#include "JsonObjectConverter.h"
-#include "Mixpanel.h"
-#include "LogSpeckle.h"
-#include "API/ClientAPI.h"
-
-
-USpeckleStreamAPIOperation* USpeckleStreamAPIOperation::SpeckleStreamAPIOperation(
-																		const FString& ServerUrl,
-																		const FString& AuthToken,
-																		const FString& GraphQlQuery,
-																		const FString& ResponsePropertyName, 
-																		const FString& RequestLogName)
-{
-    USpeckleStreamAPIOperation* Node = NewObject<USpeckleStreamAPIOperation>();
-    Node->ServerUrl = ServerUrl.TrimEnd();
-	Node->AuthToken = AuthToken.TrimEnd();
-	Node->Query = GraphQlQuery;
-	Node->ResponsePropertyName = ResponsePropertyName;
-	Node->RequestLogName = RequestLogName;
-	
-    return Node;
-}
-
-void USpeckleStreamAPIOperation::Activate()
-{
-	FAnalytics::TrackEvent(ServerUrl, "NodeRun", TMap<FString, FString> { {"name", RequestLogName} });
-
-	Request();
-}
-
-void USpeckleStreamAPIOperation::Request()
-{
-	FString Payload = FString::Printf(TEXT("{\"query\": \"%s\"}"), *Query.ReplaceCharWithEscapedChar());
-	FAPIResponceDelegate CompleteDelegate;
-	CompleteDelegate.BindUObject(this, &USpeckleStreamAPIOperation::HandleReceive);
-
-	FErrorDelegate ErrorDelegate;
-	ErrorDelegate.BindUObject(this, &USpeckleStreamAPIOperation::HandleError);
-	FClientAPI::MakeGraphQLRequest(ServerUrl, AuthToken, ResponsePropertyName, Payload,RequestLogName , CompleteDelegate, ErrorDelegate);
-}
-
-void USpeckleStreamAPIOperation::HandleReceive(const FString& ResponseJson)
-{
-	check(IsInGameThread());
-	
-	UE_LOG(LogSpeckle, Log, TEXT("%s to %s Succeeded"), *StaticClass()->GetName(), *ServerUrl);
-	
-	FEditorScriptExecutionGuard ScriptGuard;
-	OnReceiveSuccessfully.Broadcast(ResponseJson, "");		
-	
-	SetReadyToDestroy();
-}
-
-void USpeckleStreamAPIOperation::HandleError(const FString& Message)
-{
-	check(IsInGameThread());
-	
-	UE_LOG(LogSpeckle, Warning, TEXT("%s failed - %s"), *StaticClass()->GetName(), *Message);
-	
-	FEditorScriptExecutionGuard ScriptGuard;
-	OnError.Broadcast("", Message);
-		
-	SetReadyToDestroy();
-}
-

Source/SpeckleUnreal/Private/API/SpeckleAPIFunctions.cpp

@@ -1,60 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-
-
-#include "API/SpeckleAPIFunctions.h"
-
-#include "JsonObjectConverter.h"
-
-bool USpeckleAPIFunctions::DeserializeResponse(const FString& JsonString, int32& OutStruct)
-{
-	// We should never hit this!  stubs to avoid NoExport on the class.
-	check(0);
-	return false;
-}
-
-
-bool USpeckleAPIFunctions::GenericDeserializeResponse(const FString& JsonString, const UScriptStruct* StructType,
-	void* OutStruct)
-{
-	//see FJsonObjectConverter::JsonObjectStringToUStruct
-	TSharedPtr<FJsonObject> JsonObject;
-	TSharedRef<TJsonReader<> > JsonReader = TJsonReaderFactory<>::Create(JsonString);
-	if (!FJsonSerializer::Deserialize(JsonReader, JsonObject) || !JsonObject.IsValid())
-	{
-		UE_LOG(LogJson, Warning, TEXT("JsonObjectStringToUStruct - Unable to parse json=[%s]"), *JsonString);
-		return false;
-	}
-	if (!FJsonObjectConverter::JsonObjectToUStruct(JsonObject.ToSharedRef(), StructType, OutStruct, 0, 0))
-	{
-		UE_LOG(LogJson, Warning, TEXT("JsonObjectStringToUStruct - Unable to deserialize. json=[%s]"), *JsonString);
-		return false;
-	}
-	return true;
-}
-
-void USpeckleAPIFunctions::CommitReceived(FSpeckleCommit& Commit)
-{
-	//TODO send read read receipt
-	//FString Query = FString::Printf(TEXT("mutation{ commitReceive(input:%s) }"), );
-}
-
-DEFINE_FUNCTION(USpeckleAPIFunctions::execDeserializeResponse)
-{
-	// Get JsonString
-	P_GET_PROPERTY(FStrProperty, JsonString);
-	
-	// Get OutStruct
-	Stack.MostRecentPropertyAddress = nullptr;
-	Stack.StepCompiledIn<FStructProperty>(nullptr);
-	void* OutBlueprintDataPtr = Stack.MostRecentPropertyAddress;
-	FStructProperty* StructProp = CastField<FStructProperty>(Stack.MostRecentProperty);
-	UScriptStruct* StructType = StructProp->Struct;
-	
-	P_FINISH;
-	
-	P_NATIVE_BEGIN;
-	
-	*static_cast<bool*>(RESULT_PARAM) = GenericDeserializeResponse(JsonString, StructType, OutBlueprintDataPtr);
-	P_NATIVE_END;
-}

Source/SpeckleUnreal/Private/API/SpeckleSerializer.cpp

@@ -1,6 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "API/SpeckleSerializer.h"
+#include "API/SpeckleSerializer.h"
 
 #include "Objects/Base.h"
 #include "LogSpeckle.h"
@@ -11,6 +9,7 @@
 #include "UObject/Package.h"
 
 
+// Create the Deserialization Base
 UBase* USpeckleSerializer::DeserializeBase(const TSharedPtr<FJsonObject> Obj,
 										   const TScriptInterface<ITransport> ReadTransport)
 {

Source/SpeckleUnreal/Private/Analytics.cpp

@@ -1,6 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "Mixpanel.h"
+#include "Mixpanel.h"
 
 #include "Containers/UnrealString.h"
 #include "HttpModule.h"
@@ -17,27 +15,17 @@ const FString FAnalytics::MixpanelToken = TEXT("acd87c5a50b56df91a795e999812a3a4
 const FString FAnalytics::MixpanelServer = TEXT("https://analytics.speckle.systems");
 const FString FAnalytics::VersionedApplicationName = FString::Printf(TEXT("Unreal Engine %d.%d"), ENGINE_MAJOR_VERSION, ENGINE_MINOR_VERSION);
 
-void FAnalytics::TrackEvent(const FString& Server, const FString& EventName)
+void FAnalytics::TrackEvent(const FString& Email, const FString& Server, const FString& EventName)
 {
-#if !SUPPRESS_SPECKLE_ANALYTICS
 	const TMap<FString, FString> CustomProperties;
-	TrackEvent( Server, EventName, CustomProperties);
-#endif
-}
-
-void FAnalytics::TrackEvent(const FString& Server, const FString& EventName, const TMap<FString, FString>& CustomProperties)
-{
-#if !SUPPRESS_SPECKLE_ANALYTICS
-	//Since we don't have access to users email address, we will hash the system user name instead (better than not tracking users at all) 
-	const FString Email = FString(FGenericPlatformProcess::ComputerName()) + FString(FGenericPlatformProcess::UserName());
 	TrackEvent(Email, Server, EventName, CustomProperties);
-#endif
 }
 
 void FAnalytics::TrackEvent(const FString& Email, const FString& Server, const FString& EventName, const TMap<FString, FString>& CustomProperties)
 {
 #if !SUPPRESS_SPECKLE_ANALYTICS
 
+	
 	FString HashedEmail = "@" + Hash(Email); //prepending an @ so we distinguish logged and non-logged users
 	FString HashedServer = Hash(Server);
 	

Source/SpeckleUnreal/Private/Conversion/Converters/AggregateConverter.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
 
 #include "Conversion/Converters/AggregateConverter.h"
 
@@ -57,6 +57,13 @@ UObject* UAggregateConverter::ConvertToNativeInternal(const UBase* Object, UWorl
 	UObject* Converter = GetConverter(Type).GetObject();
 	if(!IsValid(Converter))
 	{
+		//TODO convert displayValues then halt traversal
+			
+		
+		
+
+		
+		
 		if(Type != UBase::StaticClass())
 		{
 			UE_LOG(LogSpeckle, Warning, TEXT("Skipping Object %s: No conversion functions exist for %s"), *Object->Id, *Type->GetName());

Source/SpeckleUnreal/Private/Conversion/Converters/BlockConverter.cpp

@@ -1,6 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "Conversion/Converters/BlockConverter.h"
+#include "Conversion/Converters/BlockConverter.h"
 
 #include "Objects/Other/BlockInstance.h"
 #include "Objects/Utils/SpeckleObjectUtils.h"

Source/SpeckleUnreal/Private/Conversion/Converters/MaterialConverter.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Conversion/Converters/MaterialConverter.h"
 

Source/SpeckleUnreal/Private/Conversion/Converters/PointCloudConverter.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Conversion/Converters/PointCloudConverter.h"
 

Source/SpeckleUnreal/Private/Conversion/Converters/ProceduralMeshConverter.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
 
 #include "Conversion/Converters/ProceduralMeshConverter.h"
 
@@ -10,6 +10,7 @@
 #include "Objects/Other/RenderMaterial.h"
 #include "Objects/Utils/SpeckleObjectUtils.h"
 
+// Setup some basics
 UProceduralMeshConverter::UProceduralMeshConverter()
 {
     SpeckleTypes.Add(UMesh::StaticClass());
@@ -19,6 +20,7 @@ UProceduralMeshConverter::UProceduralMeshConverter()
     ActorMobility = EComponentMobility::Static;
 }
 
+// Blueprint for converting data to 3D model 
 UObject* UProceduralMeshConverter::ConvertToNative_Implementation(const UBase* SpeckleBase, UWorld* World,
                                                             TScriptInterface<ISpeckleConverter>& AvailableConverters )
 {

Source/SpeckleUnreal/Private/Conversion/Converters/StaticMeshConverter.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
 
 #include "Conversion/Converters/StaticMeshConverter.h"
 
@@ -14,15 +14,25 @@
 #include "Conversion/Converters/MaterialConverter.h"
 #include "Misc/ScopedSlowTask.h"
 #include "Objects/DisplayValueElement.h"
+#include "Objects/Geometry/Box.h"
 #include "Objects/Other/RenderMaterial.h"
 #include "Objects/Utils/SpeckleObjectUtils.h"
 
 #define LOCTEXT_NAMESPACE "FSpeckleUnrealModule"
 
+bool UStaticMeshConverter::CanConvertToNative_Implementation(TSubclassOf<UBase> BaseType)
+{
+	if(EnabledTypes.Contains(BaseType))
+		return EnabledTypes[BaseType];
+	
+	return false;
+}
+
 UStaticMeshConverter::UStaticMeshConverter()
 {
-	SpeckleTypes.Add(UMesh::StaticClass());
-	SpeckleTypes.Add(UDisplayValueElement::StaticClass());
+	EnabledTypes.Add(UMesh::StaticClass(), true);
+	EnabledTypes.Add(UDisplayValueElement::StaticClass(), true);
+	EnabledTypes.Add(UBoxx::StaticClass(), true);
 	
 #if WITH_EDITORONLY_DATA
 	UseFullBuild = true;
@@ -58,6 +68,15 @@ UObject* UStaticMeshConverter::ConvertToNative_Implementation(const UBase* Speck
 		return MeshToNativeActor(m, World, AvailableConverters);
 	}
 	
+	
+	const UBoxx* b = Cast<UBoxx>(SpeckleBase);
+	if(b != nullptr)
+	{
+		//Handle Element with Display Values
+		const UMesh* m = b->ToMesh();
+		return MeshToNativeActor(m, World, AvailableConverters);
+	}
+	
 	const UDisplayValueElement* d = Cast<UDisplayValueElement>(SpeckleBase);
 	if(d != nullptr)
 	{
@@ -262,13 +281,6 @@ UStaticMesh* UStaticMeshConverter::MeshesToNativeMesh(UObject* Outer, const UBas
 			for(int j = 0; j < n; j ++)
 			{
 				int32 VertIndex = SpeckleMesh->Faces[i + 1 + j];
-				
-				if(VertIndex < 0 || VertIndex >= Vertices.Num())
-				{
-					UE_LOG(LogSpeckle, Warning, TEXT("Invalid Polygon while creating mesh %s - index %d was outside the bounds of the vertex array, face is ignored"), *SpeckleMesh->Id, VertIndex);
-					continue;
-				}
-				
 				FVertexID Vert = Vertices[VertIndex];
 				bool AlreadyInSet;
 				Verts.Add(Vert, &AlreadyInSet);
@@ -399,8 +411,7 @@ UBase* UStaticMeshConverter::MeshToSpeckle(const UStaticMeshComponent* Object)
 
 void UStaticMeshConverter::FinishConversion_Implementation()
 {
-	if(StaticMeshesToBuild.Num() <= 0) return;
-	
+
 	FScopeLock Lock(&Lock_StaticMeshesToBuild);
 
 #if WITH_EDITOR

Source/SpeckleUnreal/Private/Conversion/SpeckleConverterComponent.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Conversion/SpeckleConverterComponent.h"
 
@@ -10,10 +11,13 @@
 #include "Conversion/Converters/StaticMeshConverter.h"
 #include "Conversion/Converters/MaterialConverter.h"
 #include "Misc/ScopedSlowTask.h"
+#include "Transports/Transport.h"
 #include "UObject/ConstructorHelpers.h"
+#include "LogSpeckle.h"
 
 #define LOCTEXT_NAMESPACE "FSpeckleUnrealModule"
 
+// Sets default values for this component's properties
 USpeckleConverterComponent::USpeckleConverterComponent()
 {
 	//TODO consider using an object library for default converters
@@ -56,6 +60,21 @@ AActor* USpeckleConverterComponent::RecursivelyConvertToNative(AActor* AOwner, c
 	return RootActor;
 }
 
+// We should convert JSON to Speckle Object Streams
+TArray<FSpeckleStream> USpeckleConverterComponent::ConvertStreamsToNative(AActor* AOwner, const UBase* Base,
+	const TScriptInterface<ITransport>& LocalTransport, bool DisplayProgressBar, TArray<AActor*>& OutActors)
+{
+
+	return ArrayOfStreams;
+}
+
+
+
+
+
+
+
+
 AActor* USpeckleConverterComponent::RecursivelyConvertToNative_Internal(AActor* AOwner, const UBase* Base,
                                                                         const TScriptInterface<ITransport>& LocalTransport,
                                                                         FSlowTask* Task,
@@ -87,7 +106,7 @@ AActor* USpeckleConverterComponent::RecursivelyConvertToNative_Internal(AActor*
 	{
 		if(Task->ShouldCancel()) break;
 		
-		ConvertChild(Kvp.Value, NextOwner, LocalTransport, Task, OutActors);
+		ConvertChild(Kvp.Value, AOwner, LocalTransport, Task, OutActors);
 	}
 	return AOwner;
 }
@@ -109,7 +128,7 @@ void USpeckleConverterComponent::ConvertChild(const TSharedPtr<FJsonValue> Objec
 	const TArray<TSharedPtr<FJsonValue>>* ChildArr;
 	if (Object->TryGetArray(ChildArr))
 	{
-		for (const auto& v : *ChildArr)
+		for (const auto v : *ChildArr)
 		{
 			ConvertChild(v, AOwner, LocalTransport, Task, OutActors);
 		}

Source/SpeckleUnreal/Private/LogSpeckle.cpp

@@ -1,6 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "LogSpeckle.h"
+#include "LogSpeckle.h"
 #include "Logging/LogMacros.h"
 
 DEFINE_LOG_CATEGORY(LogSpeckle);

Source/SpeckleUnreal/Private/Objects/DisplayValueElement.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Objects/DisplayValueElement.h"
 

Source/SpeckleUnreal/Private/Objects/Geometry/Box.cpp

@@ -0,0 +1,55 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "Objects/Geometry/Box.h"
+
+#include "Objects/Geometry/Plane.h"
+#include "Objects/Utils/SpeckleObjectUtils.h"
+
+bool UBoxx::Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport)
+{
+	if(!Super::Parse(Obj, ReadTransport)) return false;
+	
+	const float ScaleFactor = USpeckleObjectUtils::ParseScaleFactor(Units);
+
+	const FString BasePlanePropertyName = TEXT("basePlane");
+	if (Obj->HasField(BasePlanePropertyName))
+	{
+		BasePlane = NewObject<UPlane>();
+		if(!BasePlane->Parse(Obj->GetObjectField(BasePlanePropertyName), ReadTransport)) return false;
+		DynamicProperties.Remove(BasePlanePropertyName);
+	}
+
+	if(!USpeckleObjectUtils::ParseVectorProperty(Obj, "xSize", ReadTransport, XSize)) return false;
+	XSize *= ScaleFactor;
+	DynamicProperties.Remove("xSize");
+	
+	if(!USpeckleObjectUtils::ParseVectorProperty(Obj, "ySize", ReadTransport, YSize)) return false;
+	YSize *= ScaleFactor;
+	DynamicProperties.Remove("ySize");
+	
+	
+	return true;
+}
+
+UMesh* UBoxx::ToMesh(UObject* Outer) const
+{
+
+	TArray<FVector> Vertices = {
+		FVector(),
+		FVector(),
+		FVector(),
+		FVector(),
+		FVector(),
+		FVector(),
+	};
+
+	TArray<int32> Faces = {
+	};
+	
+	//FMatrix transform = 
+	
+	
+	UMesh* Mesh = NewObject<UMesh>(Outer);
+	return Mesh;
+}

Source/SpeckleUnreal/Private/Objects/Geometry/Mesh.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Objects/Geometry/Mesh.h"
 
@@ -46,7 +47,7 @@ bool UMesh::Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITra
 	{
 		const TArray<TSharedPtr<FJsonValue>> FaceVertices = USpeckleObjectUtils::CombineChunks(Obj->GetArrayField("faces"), ReadTransport);
 		Faces.Reserve(FaceVertices.Num());
-		for(const auto& VertIndex : FaceVertices)
+		for(const auto VertIndex : FaceVertices)
 		{
 			Faces.Add(VertIndex->AsNumber());
 		}
@@ -105,7 +106,11 @@ bool UMesh::Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITra
 }
 
 
-
+/**
+ * If not already so, this method will align vertices
+ * such that a vertex and its corresponding texture coordinates have the same index.
+ * See "https://github.com/specklesystems/speckle-sharp/blob/main/Objects/Objects/Geometry/Mesh.cs"
+ */
 void UMesh::AlignVerticesWithTexCoordsByIndex()
 {
 	if(TextureCoordinates.Num() == 0) return;

Source/SpeckleUnreal/Private/Objects/Geometry/Plane.cpp

@@ -0,0 +1,31 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+
+#include "Objects/Geometry/Plane.h"
+
+#include "Objects/Utils/SpeckleObjectUtils.h"
+
+bool UPlane::Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport)
+{
+	if(!Super::Parse(Obj, ReadTransport)) return false;
+	
+	const float ScaleFactor = USpeckleObjectUtils::ParseScaleFactor(Units);
+	
+	if(!USpeckleObjectUtils::ParseVectorProperty(Obj, "origin", ReadTransport, Origin)) return false;
+	Origin *= ScaleFactor;
+	DynamicProperties.Remove("origin");
+	
+	if(!USpeckleObjectUtils::ParseVectorProperty(Obj, "normal", ReadTransport, Normal)) return false;
+	Normal *= ScaleFactor;
+	DynamicProperties.Remove("normal");
+	
+	if(!USpeckleObjectUtils::ParseVectorProperty(Obj, "ydir", ReadTransport, XDir)) return false;
+	XDir *= ScaleFactor;
+	DynamicProperties.Remove("ydir");
+	
+	if(!USpeckleObjectUtils::ParseVectorProperty(Obj, "xdir", ReadTransport, YDir)) return false;
+	YDir *= ScaleFactor;
+	DynamicProperties.Remove("xdir");
+		
+	return true;
+}

Source/SpeckleUnreal/Private/Objects/Geometry/PointCloud.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Objects/Geometry/PointCloud.h"
 

Source/SpeckleUnreal/Private/Objects/ObjectModelRegistry.cpp

@@ -1,6 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "Objects/ObjectModelRegistry.h"
+#include "Objects/ObjectModelRegistry.h"
 
 #include "Objects/Base.h"
 #include "Templates/SubclassOf.h"

Source/SpeckleUnreal/Private/Objects/Other/BlockInstance.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Objects/Other/BlockInstance.h"
 #include "LogSpeckle.h"
@@ -36,7 +37,7 @@ bool UBlockInstance::Parse(const TSharedPtr<FJsonObject> Obj,  const TScriptInte
 		return false;
 	}
 	
-	for(const auto& Geo : Geometries)
+	for(const auto Geo : Geometries)
 	{
 		const TSharedPtr<FJsonObject> MeshReference = Geo->AsObject();
 		const FString ChildId = MeshReference->GetStringField("referencedId");

Source/SpeckleUnreal/Private/Objects/Other/View3D.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Copyright AEC Systems Ltd
+
 
 #include "Objects/Other/View3D.h"
 

Source/SpeckleUnreal/Private/Objects/Utils/SpeckleObjectUtils.cpp

@@ -1,4 +1,5 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Objects/Utils/SpeckleObjectUtils.h"
 
@@ -142,6 +143,41 @@ bool USpeckleObjectUtils::ParseVector(const TSharedPtr<FJsonObject> Object,
 	return ParseSpeckleObject<UMesh>(Obj, Transport, Mesh);
 }
 
+bool USpeckleObjectUtils::ParseIntervalProperty(const TSharedPtr<FJsonObject> Base, const FString& PropertyName,
+	const TScriptInterface<ITransport> ReadTransport, FVector2f<float>& OutObject)
+{
+	const TSharedPtr<FJsonObject>* OriginObject;
+	if(Base->TryGetObjectField(PropertyName, OriginObject)
+		&& ParseInterval(*OriginObject, ReadTransport, OutObject))
+	{
+		return true;
+	}
+	
+	return false;
+}
+
+bool USpeckleObjectUtils::ParseInterval(const TSharedPtr<FJsonObject> Object,
+	const TScriptInterface<ITransport> Transport, FVector2f& OutObject)
+{
+	if(!ensure(Object != nullptr)) return false;
+	
+	TSharedPtr<FJsonObject> Obj;
+	if(!ResolveReference(Object, Transport, Obj)) Obj = Object;
+	
+	double x = 0, y = 0, z = 0;
+	
+	if(!(Obj->TryGetNumberField("start", x)
+		&& Obj->TryGetNumberField("end", y)) return false;
+
+	OutObject = FVector2f(x,y,z);
+	//return true;
+
+	UMesh* Mesh;
+	return ParseSpeckleObject<UMesh>(Obj, Transport, Mesh);
+}
+
+
+
 template <typename TBase>  
 bool USpeckleObjectUtils::ParseSpeckleObject(const TSharedPtr<FJsonObject> Object,
 	const TScriptInterface<ITransport> Transport, TBase*& OutObject)
@@ -157,16 +193,7 @@ bool USpeckleObjectUtils::ParseSpeckleObject(const TSharedPtr<FJsonObject> Objec
 }
 
 
-AActor* USpeckleObjectUtils::SpawnActorInWorld(const UObject* WorldContextObject, const TSubclassOf<AActor> Class, UPARAM(ref) const FTransform& Transform)
+AActor* USpeckleObjectUtils::SpawnActorInWorld(const TSubclassOf<AActor> Class, UWorld* World, const FTransform& Transform)
 {
-	return WorldContextObject->GetWorld()->SpawnActor(Class, &Transform, FActorSpawnParameters());
-}
-
-FString USpeckleObjectUtils::DisplayAsString(const FString& msg, const TSharedPtr<FJsonObject> Obj)
-{
-	FString OutputString;
-	TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
-	FJsonSerializer::Serialize(Obj.ToSharedRef(), Writer);
-	UE_LOG(LogSpeckle, Display, TEXT("resulting jsonString from %s -> %s"), *msg, *OutputString);
-	return OutputString;
+	return World->SpawnActor(Class, &Transform, FActorSpawnParameters());
 }

Source/SpeckleUnreal/Private/ReceiveSelectionComponent.cpp

@@ -1,428 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#include "ReceiveSelectionComponent.h"
-
-#include "JsonObjectConverter.h"
-#include "LogSpeckle.h"
-#include "API/ClientAPI.h"
-#include "API/Models/SpeckleUser.h"
-
-#if WITH_EDITOR
-void UReceiveSelectionComponent::PostEditChangeProperty(FPropertyChangedEvent& e)
-{
-	Super::PostEditChangeProperty(e);
-
-	const FName PropertyName = (e.Property != nullptr) ? e.Property->GetFName() : NAME_None;
-	PropertyChangeHandler(PropertyName);
-}
-#endif
-
-void UReceiveSelectionComponent::PropertyChangeHandler(const FName& PropertyName)
-{
-	if(bManualMode) return;
-		
-	if (PropertyName == GET_MEMBER_NAME_CHECKED(UReceiveSelectionComponent, bManualMode))
-	{
-		Refresh();
-	}
-	else if (PropertyName == GET_MEMBER_NAME_CHECKED(UReceiveSelectionComponent, AuthToken)
-		|| PropertyName == GET_MEMBER_NAME_CHECKED(UReceiveSelectionComponent, ServerUrl))
-	{
-		IsAccountValid = !AuthToken.IsEmpty() && !ServerUrl.IsEmpty();
-		if(IsAccountValid)
-		{
-			//TODO maybe we should check URL is a valid URL?
-			ServerUrl.TrimEndInline();
-			while(ServerUrl.RemoveFromEnd("/")) { }
-			AuthToken.TrimEndInline();
-		}
-
-		UpdateStreams();
-	}
-	else if (PropertyName == GET_MEMBER_NAME_CHECKED(UReceiveSelectionComponent, SelectedStreamText)
-		&& !SelectedStreamText.IsEmpty())
-	{
-		IsStreamValid = Streams.Contains(SelectedStreamText);
-		if(IsStreamValid)
-		{
-			SelectStream(SelectedStreamText);
-		}
-		else UpdateStreams();
-	} 
-	else if (PropertyName == GET_MEMBER_NAME_CHECKED(UReceiveSelectionComponent, SelectedBranchText)
-		&& !SelectedBranchText.IsEmpty())
-	{
-		IsBranchValid = Branches.Contains(SelectedBranchText);
-		if(IsBranchValid)
-		{
-			SelectBranch(SelectedBranchText);
-		}
-		else UpdateBranches();
-	}
-	else if (PropertyName == GET_MEMBER_NAME_CHECKED(UReceiveSelectionComponent, SelectedCommitText)
-		&& !SelectedCommitText.IsEmpty())
-	{
-		IsCommitValid = Commits.Contains(SelectedCommitText);
-		if(IsCommitValid)
-		{
-			SelectCommit(SelectedCommitText);
-		}
-		else UpdateCommits();
-	}
-}
-
-
-void UReceiveSelectionComponent::Refresh()
-{
-	IsAccountValid = !AuthToken.IsEmpty() && !ServerUrl.IsEmpty();
-
-	UpdateStreams();
-}
-
-
-bool UReceiveSelectionComponent::TryGetSelectedCommit(FSpeckleCommit& OutCommit) const
-{
-	if(!bManualMode && IsCommitValid)
-	{
-		OutCommit = Commits.FindRef(SelectedCommitText);
-		return true;
-	}
-	return false;
-}
-
-bool UReceiveSelectionComponent::TryGetSelectedBranch(FSpeckleBranch& OutBranch) const
-{
-	if(!bManualMode && IsBranchValid)
-	{
-		OutBranch = Branches.FindRef(SelectedBranchText);
-		return true;
-	}
-	return false;
-}
-
-bool UReceiveSelectionComponent::TryGetSelectedStream(FSpeckleStream& OutStream) const
-{
-	if(!bManualMode && IsStreamValid)
-	{
-		OutStream = Streams.FindRef(SelectedStreamText);
-		return true;
-	}
-	return false;
-}
-
-void UReceiveSelectionComponent::OpenURLInBrowser() const
-{
-	const FString URL = GetUrl();
-
-	if(!ensure(FPlatformProcess::CanLaunchURL(*URL))) return;
-
-	FString LaunchErrors;
-	FPlatformProcess::LaunchURL(*URL, nullptr, &LaunchErrors);
-
-	if(LaunchErrors.IsEmpty())
-	{
-		UE_LOG(LogSpeckle, Log, TEXT("Launched URL \"%s\" in browser"), *URL);
-	}
-	else
-	{
-		UE_LOG(LogSpeckle, Warning, TEXT("Failed to launched URL \"%s\" in browser - %s"), *URL, *LaunchErrors);
-	}
-
-}
-
-bool UReceiveSelectionComponent::IsSelectionComplete(FString& OutStatusMessage) const
-{
-	if(bManualMode)
-	{
-		if(ServerUrl.IsEmpty()) OutStatusMessage = TEXT("Server Url is invalid, must specify a valid url");
-		else if(StreamId.IsEmpty()) OutStatusMessage = TEXT("Stream id is invalid, must specify a streamId");
-		else if(ObjectId.IsEmpty()) OutStatusMessage = TEXT("Object id is invalid, must specify a objectId");
-		else
-		{
-			OutStatusMessage = TEXT("Ready to recieve object");
-			return true;
-		}
-	}
-	else
-	{
-		if(!IsAccountValid) OutStatusMessage = TEXT("Account is invalid, please specify a valid server URL and token. (tokens can be created from your Speckle profiles page)"); 
-		else if(!IsStreamValid) OutStatusMessage = TEXT("Selected stream is invalid");
-		else if(!IsBranchValid) OutStatusMessage = TEXT("Selected branch is invalid");
-		else if(!IsCommitValid) OutStatusMessage = TEXT("Selected commit is invalid");
-		else
-		{
-			ensure(!ServerUrl.IsEmpty());
-			ensure(!StreamId.IsEmpty());
-			ensure(!ObjectId.IsEmpty());
-			OutStatusMessage = TEXT("Ready to recieve commit");
-			return true;
-		}
-	}
-	return false;
-}
-
-FString UReceiveSelectionComponent::GetUrl() const
-{
-	if(bManualMode)
-	{
-		return FString::Printf(TEXT("%s/streams/%s/objects/%s"),
-			*ServerUrl, *StreamId, *ObjectId);
-	}
-	
-	if(!IsStreamValid) return ServerUrl;
-	
-	if(!IsBranchValid)
-		return FString::Printf(TEXT("%s/streams/%s/"),
-			*ServerUrl, *GetSelectedStream().ID);
-
-	if(!IsCommitValid)
-		return FString::Printf(TEXT("%s/streams/%s/branches/%s"),
-			*ServerUrl, *GetSelectedStream().ID, *GetSelectedBranch().Name);
-	
-	return FString::Printf(TEXT("%s/streams/%s/commits/%s"),
-			*ServerUrl, *GetSelectedStream().ID, *GetSelectedCommit().ID);
-}
-
-TArray<FString> UReceiveSelectionComponent::GetStreamsOptions() const
-{
-	TArray<FString> Options;
-	Streams.GetKeys(Options);
-	return Options;
-}
-
-bool UReceiveSelectionComponent::SelectStream(const FString& DisplayId)
-{
-	const bool IsValid = !DisplayId.IsEmpty() && Streams.Contains(DisplayId);
-	if(IsValid && !bManualMode)
-	{
-		SelectedStreamText = DisplayId;
-		IsStreamValid = true;
-		StreamId = GetSelectedStream().ID;
-	}
-	else
-	{
-		SelectedStreamText = "";
-		IsStreamValid = false;
-	}
-	UpdateBranches();
-	return IsStreamValid;
-}
-
-void UReceiveSelectionComponent::UpdateStreams()
-{
-	Streams.Reset();
-	SelectStream("");
-
-	if(!IsAccountValid || bManualMode) return;
-	
-	const FString LogName(__FUNCTION__);
-	const FString Payload = FString::Printf(TEXT("{\"query\": \"query{user{id streams(limit: %d){items{id name}}}}\"}"), Limit);
-
-	//Response Handling
-	auto OnComplete = [&](const FString& ResponseJson)
-	{
-		if(bManualMode) return;
-
-		FSpeckleUser Response;
-
-		if(!ensure(FJsonObjectConverter::JsonObjectStringToUStruct(*ResponseJson, &Response, 0, 0))) return;
-
-		const TArray<FSpeckleStream>& AvailableStreams = Response.Streams.Items;
-		//Assemble stream map
-		Streams.Reserve(AvailableStreams.Num());
-		for(const auto& s : Response.Streams.Items)
-		{
-			FString DisplayId = FString::Printf(TEXT("%s - %s"), *s.Name, *s.ID);
-			Streams.Add(DisplayId, s);
-		}
-
-		//Set default selection
-		if(AvailableStreams.Num() > 0)
-		{
-			const FSpeckleStream& s = AvailableStreams[0];
-			FString DisplayId = FString::Printf(TEXT("%s - %s"), *s.Name, *s.ID);
-
-			SelectStream(DisplayId);
-		}
-		
-		UE_LOG(LogSpeckle, Verbose, TEXT("%s was successful"), *LogName);
-	};
-	FAPIResponceDelegate CompleteDelegate;
-	CompleteDelegate.BindLambda(OnComplete);
-
-	//On error
-	FErrorDelegate ErrorDelegate;
-	ErrorDelegate.BindStatic(LogError, LogName);
-
-	FClientAPI::MakeGraphQLRequest(ServerUrl, AuthToken, "user", Payload, LogName, CompleteDelegate, ErrorDelegate);
-	
-}
-
-FSpeckleStream UReceiveSelectionComponent::GetSelectedStream() const
-{
-	return Streams[SelectedStreamText];
-}
-
-TArray<FString> UReceiveSelectionComponent::GetBranchOptions()
-{
-	TArray<FString> Options;
-	Branches.GetKeys(Options);
-	return Options;
-}
-
-bool UReceiveSelectionComponent::SelectBranch(const FString& DisplayId)
-{
-	const bool IsValid = !DisplayId.IsEmpty() && Branches.Contains(DisplayId);
-	if(IsValid && !bManualMode)
-	{
-		SelectedBranchText = DisplayId;
-		IsBranchValid = true;
-	}
-	else
-	{
-		SelectedBranchText = "";
-		IsBranchValid=false;
-	}
-	UpdateCommits();
-	return IsBranchValid;
-}
-
-
-void UReceiveSelectionComponent::UpdateBranches()
-{
-	Branches.Reset();
-	SelectBranch("");
-
-	if(!IsStreamValid || bManualMode) return;
-
-	const FString LogName(__FUNCTION__);
-	const FString Payload = FString::Printf(TEXT("{\"query\": \"query{stream(id: \\\"%s\\\"){branches(limit: %d){items{id name}}}}\"}"), *GetSelectedStream().ID, Limit);
-
-	//Response Handling
-	auto OnComplete = [&](const FString& ResponseJson)
-	{
-		if(bManualMode) return;
-		
-		FSpeckleStream Response;
-		
-		if(!ensure(FJsonObjectConverter::JsonObjectStringToUStruct(*ResponseJson, &Response, 0, 0))) return;
-
-		const TArray<FSpeckleBranch>& AvailableBranches = Response.Branches.Items;
-		
-		//Assemble stream map
-		Branches.Reserve(AvailableBranches.Num());
-		for(const auto& b : AvailableBranches)
-		{
-			FString DisplayId = FString::Printf(TEXT("%s"), *b.Name);
-			Branches.Add(DisplayId, b);
-		}
-		
-		UE_LOG(LogSpeckle, Verbose, TEXT("%s was successful"), *LogName);
-		
-		//Set default selection
-		if(AvailableBranches.Num() > 0)
-		{
-			const FSpeckleBranch& b = AvailableBranches[0];
-			FString DisplayId = FString::Printf(TEXT("%s"), *b.Name);
-
-			SelectBranch(DisplayId);
-		}
-	};
-	FAPIResponceDelegate CompleteDelegate;
-	CompleteDelegate.BindLambda(OnComplete);
-
-	//On error
-	FErrorDelegate ErrorDelegate;
-	ErrorDelegate.BindStatic(LogError, LogName);
-
-	FClientAPI::MakeGraphQLRequest(ServerUrl, AuthToken, "stream", Payload,LogName, CompleteDelegate, ErrorDelegate);
-}
-
-
-FSpeckleBranch UReceiveSelectionComponent::GetSelectedBranch() const
-{
-	return Branches[SelectedBranchText];
-}
-
-TArray<FString> UReceiveSelectionComponent::GetCommitOptions()
-{
-	TArray<FString> Options;
-	Commits.GetKeys(Options);
-	return Options;
-}
-
-bool UReceiveSelectionComponent::SelectCommit(const FString& DisplayId)
-{
-	const bool IsValid = !DisplayId.IsEmpty() && Commits.Contains(DisplayId);
-	if(IsValid && !bManualMode)
-	{
-		SelectedCommitText = DisplayId;
-		IsCommitValid = true;
-		ObjectId = GetSelectedCommit().ReferencedObject;
-	}
-	else
-	{
-		SelectedCommitText = "";
-		IsCommitValid=false;
-		ObjectId = "";
-	}
-	return IsCommitValid;
-}
-
-void UReceiveSelectionComponent::UpdateCommits()
-{
-	Commits.Reset();
-	SelectCommit("");
-
-	if(!IsBranchValid || bManualMode) return;
-	
-	const FString LogName(__FUNCTION__);
-	const FString Payload = FString::Printf(TEXT("{\"query\": \"query{stream(id: \\\"%s\\\"){branch(name: \\\"%s\\\"){commits(limit: %d){items{id message referencedObject}}}}}\"}"), *GetSelectedStream().ID, *GetSelectedBranch().Name, Limit);
-	
-	//Response Handling
-	auto OnComplete = [&](const FString& ResponseJson)
-	{
-		if(bManualMode) return;
-		
-		FSpeckleStream Response;
-
-		if(!ensure(FJsonObjectConverter::JsonObjectStringToUStruct(*ResponseJson, &Response, 0, 0))) return;
-
-		const TArray<FSpeckleCommit>& AvailableCommits = Response.Branch.Commits.Items;
-		
-		//Assemble stream map
-		for(const auto& c :AvailableCommits)
-		{
-			FString DisplayId = FString::Printf(TEXT("%s - %s"), *c.Message, *c.ID);
-			Commits.Add(DisplayId, c);
-		}
-		
-		UE_LOG(LogSpeckle, Verbose, TEXT("%s was successful"), *LogName);
-		
-		//Set default selection
-		if(AvailableCommits.Num() > 0)
-		{
-			const FSpeckleCommit& c = AvailableCommits[0];
-			FString DisplayId = FString::Printf(TEXT("%s - %s"), *c.Message, *c.ID);
-			SelectCommit(DisplayId);
-		}
-	};
-	FAPIResponceDelegate CompleteDelegate;
-	CompleteDelegate.BindLambda(OnComplete);
-
-	//On error
-	FErrorDelegate ErrorDelegate;
-	ErrorDelegate.BindStatic(LogError, LogName);
-
-	FClientAPI::MakeGraphQLRequest(ServerUrl, AuthToken, "stream", Payload,LogName, CompleteDelegate, ErrorDelegate);
-}
-
-FSpeckleCommit UReceiveSelectionComponent::GetSelectedCommit() const
-{
-	return Commits[SelectedCommitText];
-}
-
-void UReceiveSelectionComponent::LogError(const FString& Message, const FString LogName)
-{
-	UE_LOG(LogSpeckle, Warning, TEXT("%s: %s"), *LogName, *Message)
-}

Source/SpeckleUnreal/Private/SpeckleUnreal.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Copyright Epic Games, Inc. All Rights Reserved.
 
 #include "SpeckleUnreal.h"
 

Source/SpeckleUnreal/Private/SpeckleUnrealManager.cpp

@@ -1,9 +1,7 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
 #include "SpeckleUnrealManager.h"
 
-#include "ReceiveSelectionComponent.h"
 #include "API/Operations/ReceiveOperation.h"
+
 #include "Transports/MemoryTransport.h"
 #include "Transports/ServerTransport.h"
 #include "LogSpeckle.h"
@@ -12,8 +10,8 @@
 #include "Misc/ScopedSlowTask.h"
 #include "Objects/Base.h"
 #include "Mixpanel.h"
-#include "API/SpeckleAPIFunctions.h"
 #include "Engine/Engine.h"
+#include "Interfaces/IHttpRequest.h"
 
 #define LOCTEXT_NAMESPACE "FSpeckleUnrealModule"
 
@@ -25,12 +23,15 @@ ASpeckleUnrealManager::ASpeckleUnrealManager()
 	RootComponent->SetRelativeScale3D(FVector(1,1,1));
     RootComponent->SetMobility(EComponentMobility::Static);
 
+	// Convert JSON to object models
 	Converter = CreateDefaultSubobject<USpeckleConverterComponent>(FName("Converter"));
-	ReceiveSelection = CreateDefaultSubobject<UReceiveSelectionComponent>(FName("ReceiveSelection"));
+	
 	KeepCache = true;
 	DisplayProgressBar = true;
+	ServerUrl = "https://speckle.xyz";
 }
 
+// Begin Play function (Receive)
 void ASpeckleUnrealManager::BeginPlay()
 {
 	Super::BeginPlay();
@@ -38,86 +39,104 @@ void ASpeckleUnrealManager::BeginPlay()
 	if(ImportAtRuntime) Receive();
 }
 
+// Start the Receive process
 void ASpeckleUnrealManager::Receive()
 {
-	// Check object to receive has been specified properly
-	FString StatusMessage;
-	if(!ReceiveSelection->IsSelectionComplete(StatusMessage))
-	{
-		HandleError(StatusMessage);
-		return;
-	}
-
-	// Delete all actors from previous receive operations
 	DeleteObjects();
-	
-	const FString ServerUrl = ReceiveSelection->ServerUrl;
-	const FString AuthToken = ReceiveSelection->AuthToken;
-	const FString StreamId = ReceiveSelection->StreamId;
-	const FString ObjectId = ReceiveSelection->ObjectId;
-	
-	FAnalytics::TrackEvent( ServerUrl, "NodeRun", TMap<FString, FString> { {"name", StaticClass()->GetName() }, {"worldType", FString::FromInt(GetWorld()->WorldType)}});
-	FString Message = FString::Printf(TEXT("Fetching Objects from Speckle Server: %s"), *ServerUrl);
-	PrintMessage(Message);
 
-	// Setup network transports
-	UServerTransport* ServerTransport = UServerTransport::CreateServerTransport(ServerUrl,StreamId,AuthToken);
-	
-	if(!KeepCache && LocalObjectCache)
+	// Trim parameters
+	ServerUrl.TrimEndInline();
+	while(ServerUrl.RemoveFromEnd("/")) { }
+	StreamID.TrimEndInline();
+	ObjectID.TrimEndInline();
+	AuthToken.TrimEndInline();
+
+	// Analytics
+	FAnalytics::TrackEvent(
+		"unknown",
+		"unknown",
+		"NodeRun",
+		TMap<FString, FString> {
+			{"name", StaticClass()->GetName() },
+			{"worldType", FString::FromInt(GetWorld()->WorldType)}}
+	);
+
+	// Clear cache 
+	if(!KeepCache && LocalObjectCache.GetObjectRef() != nullptr)
 	{
 		LocalObjectCache.GetObjectRef()->ConditionalBeginDestroy();
 		LocalObjectCache = UMemoryTransport::CreateEmptyMemoryTransport();
 	}
-	if(!LocalObjectCache) LocalObjectCache = UMemoryTransport::CreateEmptyMemoryTransport();
 
-	// Setup delegate callbacks
+	// Probably a duplication
+	if(LocalObjectCache.GetObjectRef() == nullptr)
+	{
+		LocalObjectCache = UMemoryTransport::CreateEmptyMemoryTransport();
+	}
+	
+	// Debug message
+	FString Message = FString::Printf(TEXT("Fetching Objects from Speckle Server: %s"), *ServerUrl);
+	PrintMessage(Message);
+
+	// Error delegate
 	FTransportErrorDelegate ErrorDelegate;
 	ErrorDelegate.BindUObject(this, &ASpeckleUnrealManager::HandleError);
+
+	// Complete delegate
 	FTransportCopyObjectCompleteDelegate CompleteDelegate;
 	CompleteDelegate.BindUObject(this, &ASpeckleUnrealManager::HandleReceive, DisplayProgressBar);
-	
-	// Send request for objects
-	ServerTransport->CopyObjectAndChildren(ObjectId, LocalObjectCache, CompleteDelegate, ErrorDelegate);
 
-	// Read receipt (if receiving a commit object)
-	FSpeckleCommit Commit;
-	if(ReceiveSelection->TryGetSelectedCommit(Commit))
-	{
-		//TODO read receipt
-		USpeckleAPIFunctions::CommitReceived(Commit);
-	}
+	// Create a server transport
+	UServerTransport* ServerTransport = UServerTransport::CreateServerTransport(ServerUrl,StreamID,AuthToken);
+	
+	// Receive 
+	ServerTransport->CopyObjectAndChildren(ObjectID, LocalObjectCache, CompleteDelegate, ErrorDelegate);
 }
 
 
-
+// Handle Received JSON
 void ASpeckleUnrealManager::HandleReceive(TSharedPtr<FJsonObject> RootObject, bool DisplayProgress)
 {
 	if(RootObject == nullptr) return;
-	
+
+	// Create a Base Deserialization Object Model
 	const UBase* Res = USpeckleSerializer::DeserializeBase(RootObject, LocalObjectCache);
+
 	if(IsValid(Res))
 	{
+		// Start conversion
 		Converter->RecursivelyConvertToNative(this, Res, LocalObjectCache, DisplayProgress, Actors);
-		
+
+		// Finished Conversion - show debug message 
 		FString Message = FString::Printf(TEXT("Converted %d Actors"), Actors.Num());
 		PrintMessage(Message);
 	}
 	else
 	{
+		// Object id from Json
 		FString Id;
+
+		// Try to get JSON id field
 		RootObject->TryGetStringField("id", Id);
+
+		// Debug message for error wrt to id
 		FString Message = FString::Printf(TEXT("Failed to deserialise root object: %s"), *Id);
+
+		// Print Message
 		HandleError(Message);
 	}
 }
 
+// Error handler just prints a debug message
 void ASpeckleUnrealManager::HandleError(FString& Message)
 {
 	PrintMessage(Message, true);
 }
 
+// Print debug message
 void ASpeckleUnrealManager::PrintMessage(FString& Message, bool IsError) const
 {
+	// Show at Console log: "Error" or just "Log" message (Errors are shown in red in output console)
 	if(IsError)
 	{
 		UE_LOG(LogSpeckle, Error, TEXT("%s"), *Message);
@@ -126,16 +145,19 @@ void ASpeckleUnrealManager::PrintMessage(FString& Message, bool IsError) const
 	{
 		UE_LOG(LogSpeckle, Log, TEXT("%s"), *Message);
 	}
-	
+
+	// Error as a debug message
 	FColor Color = IsError? FColor::Red : FColor::Green;
 	GEngine->AddOnScreenDebugMessage(0, 5.0f, Color, Message);
 }
 
-
+// Delete Actors containing all the 3D models
 void ASpeckleUnrealManager::DeleteObjects()
 {
+	// If still converting, terminate process
 	Converter->FinishConversion();
-	
+
+	// Destroy actors
 	for (AActor* a : Actors)
 	{
 		if(IsValid(a)) a->Destroy();
@@ -144,4 +166,7 @@ void ASpeckleUnrealManager::DeleteObjects()
 	Actors.Empty();
 }
 
+
+
+
 #undef LOCTEXT_NAMESPACE

Source/SpeckleUnreal/Private/Tests/ReceiveSelectionComponentTest.cpp

@@ -1,79 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-
-#include "LogSpeckle.h"
-#include "Misc/AutomationTest.h"
-#include "ReceiveSelectionComponent.h"
-#include "Tests/AutomationCommon.h"
-
-#if WITH_DEV_AUTOMATION_TESTS
-
-
-class UMock : public UReceiveSelectionComponent
-{
-	friend class FReceiveSelectionComponentTest;
-	friend class FCheckValidSelection;
-	friend class FCheckLimitMatch;
-};
-
-DEFINE_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER(FCheckValidSelection, FAutomationTestBase*, Test, UMock*, SelectionComponent);
-bool FCheckValidSelection::Update()
-{
-	const UMock* s = SelectionComponent;
-	
-	Test->TestTrue(TEXT("Account valid on set"), s->IsAccountValid);
-	Test->TestTrue(TEXT("Stream valid on set"), s->IsStreamValid);
-	Test->TestTrue(TEXT("Branch valid on set"), s->IsBranchValid);
-	Test->TestTrue(TEXT("Commit valid on set"), s->IsCommitValid);
-	return true;
-}
-
-DEFINE_LATENT_AUTOMATION_COMMAND_TWO_PARAMETER(FCheckLimitMatch, FAutomationTestBase*, Test, UMock*, SelectionComponent);
-bool FCheckLimitMatch::Update()
-{
-	const UMock* s = SelectionComponent;
-	
-	Test->TestTrue(TEXT("Fetched streams is less than limit"), s->Streams.Num() <= s->Limit);
-	Test->TestTrue(TEXT("Fetched branches is less than limit"), s->Branches.Num() <= s->Limit);
-	Test->TestTrue(TEXT("Fetched commits is less than limit"), s->Commits.Num() <= s->Limit);
-	return true;
-}
-
-
-IMPLEMENT_SIMPLE_AUTOMATION_TEST(FReceiveSelectionComponentTest, "SpeckleUnreal.ReceiveSelectionComponentTest", EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter)
-
-bool FReceiveSelectionComponentTest::RunTest(const FString& Parameters)
-{
-#ifdef TEST_AUTH_TOKEN
-	UMock* s = NewObject<UMock>();
-
-	
-	//Test initialisation
-	TestFalse(TEXT("Account valid on initialise"), s->IsAccountValid);
-	TestFalse(TEXT("Stream valid on initialise"), s->IsStreamValid);
-	TestFalse(TEXT("Branch valid on initialise"), s->IsBranchValid);
-	TestFalse(TEXT("Commit valid on initialise"), s->IsCommitValid);
-	
-	
-	s->AuthToken = TEST_AUTH_TOKEN;
-	s->ServerUrl = TEXT("https://latest.speckle.dev");
-	s->bManualMode = false;
-	s->Refresh();
-	
-	//wait 5 seconds for HTTP requests to finish
-	ADD_LATENT_AUTOMATION_COMMAND(FWaitLatentCommand(5.0f));
-	
-	ADD_LATENT_AUTOMATION_COMMAND(FCheckValidSelection(this, s));
-	ADD_LATENT_AUTOMATION_COMMAND(FCheckLimitMatch(this, s));
-
-	
-#else
-	TestTrue(TEXT("TEST_AUTH_TOKEN definition exists"), false);
-	
-	return false;
-#endif
-	
-	return true;
-}
-#endif
-

Source/SpeckleUnreal/Private/Tests/Transports/ServerTransportTest.cpp

@@ -0,0 +1,25 @@
+// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+
+#include "Misc/AutomationTest.h"
+#include "Objects/Base.h"
+#include "Transports/ServerTransport.h"
+
+
+#if WITH_DEV_AUTOMATION_TESTS
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(FServerTransportTest, "SpeckleUnreal.Transports.ServerTransport", EAutomationTestFlags::EditorContext | EAutomationTestFlags::ProductFilter)
+
+
+bool FServerTransportTest::RunTest(const FString& Parameters)
+{
+	FString ServerUrl = TEXT("https://example.com");
+	FString StreamId = TEXT("1234");
+	FString Token = TEXT("MyAuthToken");
+	auto Transport = UServerTransport::CreateServerTransport(ServerUrl, StreamId, Token);
+	
+	
+	return true;
+}
+
+
+#endif

Source/SpeckleUnreal/Private/Transports/MemoryTransport.cpp

@@ -1,7 +1,7 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Transports/MemoryTransport.h"
-
 #include "LogSpeckle.h"
 
 bool UMemoryTransport::HasObject(const FString& ObjectId) const
@@ -18,5 +18,5 @@ TSharedPtr<FJsonObject> UMemoryTransport::GetSpeckleObject(const FString& Object
 void UMemoryTransport::SaveObject(const FString& ObjectId, const TSharedPtr<FJsonObject> SerializedObject)
 {
 	SpeckleObjects.Add(ObjectId, SerializedObject);
-	UE_LOG(LogSpeckle, Verbose, TEXT("Added %s to in memory transport, now %d objects total "), *ObjectId, SpeckleObjects.Num());
+	UE_LOG(LogSpeckle, Log, TEXT("-----------> ADDED <-------------- %d"), SpeckleObjects.Num());
 }

Source/SpeckleUnreal/Private/Transports/ServerTransport.cpp

@@ -1,9 +1,10 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
+
 
 #include "Transports/ServerTransport.h"
-
 #include "LogSpeckle.h"
 #include "Mixpanel.h"
+
 #include "JsonObjectConverter.h"
 #include "HttpModule.h"
 #include "Interfaces/IHttpRequest.h"
@@ -28,6 +29,7 @@ bool UServerTransport::HasObject(const FString& ObjectId) const
 	return false;
 }
 
+// Parse Root JSON
 void UServerTransport::HandleRootObjectResponse(const FString& RootObjSerialized,
 												TScriptInterface<ITransport> TargetTransport,
 												const FString& ObjectId) const
@@ -60,6 +62,7 @@ void UServerTransport::HandleRootObjectResponse(const FString& RootObjSerialized
 }
 
 
+// Create HTTP Request for Commit Root objects (only ids of children)
 void UServerTransport::CopyObjectAndChildren(const FString& ObjectId,
 											 TScriptInterface<ITransport> TargetTransport,
 											 const FTransportCopyObjectCompleteDelegate& OnCompleteAction,
@@ -109,16 +112,17 @@ void UServerTransport::CopyObjectAndChildren(const FString& ObjectId,
 		return;
 	}
 	UE_LOG(LogSpeckle, Verbose, TEXT("GET Request sent for root object at %s, awaiting response"), *Endpoint );
-	FAnalytics::TrackEvent(ServerUrl, "Receive");
+	FAnalytics::TrackEvent("unknown", ServerUrl, "Receive");
 }
 
+// Fetch Children JSON and parse it
 void UServerTransport::FetchChildren(TScriptInterface<ITransport> TargetTransport, const FString& ObjectId,
-									const TArray<FString>& ChildrenIds, int32 CStart) const
+																const TArray<FString>& ChildrenIds, int32 CStart) const
 {
 	// Check if all children have been fetched
 	if(ChildrenIds.Num() <= CStart)
 	{
-		UE_LOG(LogSpeckle, Log, TEXT("Finished fetching child Speckle objects"));
+		UE_LOG(LogSpeckle, Log, TEXT("----------->PJSON < CSTART <-----------"));
 		ensureAlwaysMsgf(this->OnComplete.ExecuteIfBound(TargetTransport->GetSpeckleObject(ObjectId)),
 		                                                               TEXT("Complete handler was not bound properly"));
 		return;
@@ -134,7 +138,8 @@ void UServerTransport::FetchChildren(TScriptInterface<ITransport> TargetTranspor
 		for (int32 i = CStart; i < CEnd; i++)
 		{
 			Writer->WriteValue(ChildrenIds[i]);
-		}		Writer->WriteArrayEnd();
+		}
+		Writer->WriteArrayEnd();
 		Writer->Close();
 	}
 
@@ -162,7 +167,7 @@ void UServerTransport::FetchChildren(TScriptInterface<ITransport> TargetTranspor
 	// Response Callback
 	auto ResponseHandler = [=](FHttpRequestPtr, FHttpResponsePtr Response, bool bWasSuccessful) mutable 
 	{
-		// Request Fail
+		// Any Fail
 		if(!bWasSuccessful)
 		{
 			FString Message = FString::Printf(TEXT("Request for children of root object %s/%s failed: %s"),
@@ -188,7 +193,7 @@ void UServerTransport::FetchChildren(TScriptInterface<ITransport> TargetTranspor
 		
 		UE_LOG(LogSpeckle, Verbose, TEXT("Parsing %d downloaded objects..."), LineCount)
 
-		// Warning: Fewer/More objects then expected
+		// Warning: Less objects then expected
 		if(LineCount != CEnd - CStart)
 		{
 			UE_LOG(LogSpeckle, Warning, TEXT("Requested %d objects, but received %d"), CEnd - CStart, LineCount);

Source/SpeckleUnreal/Public/API/ClientAPI.h

@@ -1,52 +1,80 @@
 // Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
 #pragma once
-
 #include "Interfaces/IHttpRequest.h"
 
+struct FSpeckleStream;
+struct FSpeckleBranch;
+struct FSpeckleCommit;
+struct FSpeckleGlobals;
+struct FSpeckleUser;
+
 DECLARE_DELEGATE_OneParam(FErrorDelegate, const FString&);
-DECLARE_DELEGATE_OneParam(FAPIResponceDelegate, const FString&);
+DECLARE_DELEGATE_OneParam(FFetchStreamDelegate, const TArray<FSpeckleStream>&);
+DECLARE_DELEGATE_OneParam(FFetchBranchDelegate, const TArray<FSpeckleBranch>&);
+DECLARE_DELEGATE_OneParam(FFetchCommitDelegate, const TArray<FSpeckleCommit>&);
+DECLARE_DELEGATE_OneParam(FFetchGlobalsDelegate, const FSpeckleGlobals&);
+DECLARE_DELEGATE_OneParam(FFetchUserDelegate, const FSpeckleUser&);
 
-/**
-* C++ wrapper of Speckle's GraphQL API
-* Encapsulates sending HTTP requests with GraphQL Queries for specific resources
-*
-* Used to send GraphQL requests for commits, branches, streams, user info, collaborators etc.
-*
-* See `API/Operations` for usage examples
-*/
-class FClientAPI
-{
+ /**
+  * C++ wrapper for GraphQL requests
+  * See Operations to use with blueprint
+  */
+ class FClientAPI
+ {
 
+ 	
  public:
+ 	
+ 	
 	
-	/**
-	 * Creates and sends a graphql query to the specified url.
-	 * Will check HTTP response for errors,
-	 * and unpack the response "data" object.
-	 * @param ServerUrl URL of the Speckle Server endpoint
-	 * @param AuthToken 
-	 * @param ResponsePropertyName Property name of the requested object. This will be the first name in the query (e.g. "stream", "streams", "user", etc)
-	 * @param PostPayload The POST payload containing the GraphQL request
-	 * @param RequestLogName Friendly name for this request (for error handling and logging)
-	 * @param OnCompleteAction Callback invoked on successful completion of the request, with the request object (as a JSON string)
-	 * @param OnErrorAction Callback invoked on any fatal error with, the error message.
-	 */
-	static void MakeGraphQLRequest(const FString& ServerUrl, const FString& AuthToken, const FString& ResponsePropertyName,
-	                               const FString& PostPayload, const FString& RequestLogName,
-	                               const FAPIResponceDelegate OnCompleteAction, const FErrorDelegate OnErrorAction);
+ 	static void StreamsGet(   const FString& ServerUrl,
+ 								const FString& AuthToken,
+ 								const int32 Limit,
+								const FFetchStreamDelegate OnCompleteAction,
+								const FErrorDelegate OnErrorAction);
 
-	
+ 	static void StreamGetBranches(  const FString& ServerUrl,
+ 		                        const FString& AuthToken,
+								const FString& StreamId,
+								const int32 Limit,
+								const FFetchBranchDelegate OnCompleteAction,
+								const FErrorDelegate OnErrorAction);
 
-//protected:
-	
-	/// Helper function for creating post requests with a GraphQL query
-	static FHttpRequestRef CreatePostRequest(const FString& ServerUrl, FString AuthToken, const FString& PostPayload,
-	                                         const FString& Encoding = TEXT("gzip"));
+ 	static void StreamGetCommits(   const FString& ServerUrl,
+ 	                            const FString& AuthToken,
+ 	                            const FString& StreamId,
+ 		                        const FString& BranchName,
+ 		                        const int32 Limit,
+								const FFetchCommitDelegate OnCompleteAction,
+								const FErrorDelegate OnErrorAction);
+
+ 	static void FetchGlobals(	const FString& ServerUrl,
+								const FString& AuthToken,
+								const FString& StreamId,
+								const FString& ReferencedObjectId,
+								const FFetchGlobalsDelegate OnCompleteAction,
+								const FErrorDelegate OnErrorAction);
+
+ 	static void FetchUserData(	const FString& ServerUrl,
+								const FString& AuthToken,
+								const FFetchUserDelegate OnCompleteAction,
+								const FErrorDelegate OnErrorAction);
+ 	
+
+
+
+ 	
+
+ 	//Utility functions
+
+    static FHttpRequestRef CreateGraphQLRequest(const FString& ServerUrl, FString AuthToken, const FString& PostPayload,
+                                                const FString& Encoding = TEXT("gzip"));
+ 	
+ 	static bool SendGraphQLRequest(const FHttpRequestRef Request, const FString& RequestName, const TFunctionRef<void(const FString& Message)> OnErrorAction);
 
  	static bool GetResponseAsJSON(const FHttpResponsePtr Response, const FString& RequestLogName, TSharedPtr<FJsonObject>& OutObject, const TFunctionRef<void(const FString& Message)> OnErrorAction);
-
-	static bool CheckForOperationErrors(const TSharedPtr<FJsonObject> GraphQLResponse, FString& OutErrorMessage);
+ 	
+ 	static bool CheckForOperationErrors(const TSharedPtr<FJsonObject> GraphQLResponse, FString& OutErrorMessage);
  	static bool CheckRequestFailed(bool bWasSuccessful, FHttpResponsePtr Response,  const FString& RequestName, const TFunctionRef<void(const FString& Message)> OnErrorAction);
  	
  };

Source/SpeckleUnreal/Public/API/Models/SpeckleBranch.h

@@ -1,46 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "SpeckleCommit.h"
-#include "SpeckleBranch.generated.h"
-
-/*
-* GraphQL model for Branch data
-* Properties are only when they explicitly requested (through the GraphQL request)
-* see https://github.com/specklesystems/speckle-sharp/blob/main/Core/Core/Api/GraphQL/Models.cs
-*/
-USTRUCT(BlueprintType)
-struct FSpeckleBranch
-{
-	GENERATED_BODY()
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString ID;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Name;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Description;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FSpeckleCommits Commits;
-	
-};
-
-USTRUCT(BlueprintType)
-struct FSpeckleBranches
-{
-	GENERATED_BODY();
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	int32 TotalCount;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Cursor;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	TArray<FSpeckleBranch> Items;
-};

Source/SpeckleUnreal/Public/API/Models/SpeckleCollaborator.h

@@ -1,30 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "SpeckleCollaborator.generated.h"
-
-/*
-* GraphQL model for Collaborator data
-* Properties are only when they explicitly requested (through the GraphQL request)
-* see https://github.com/specklesystems/speckle-sharp/blob/main/Core/Core/Api/GraphQL/Models.cs
-*/
-USTRUCT(BlueprintType)
-struct FSpeckleCollaborator
-{
-	GENERATED_BODY()
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Id;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Name;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Role;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Avatar;
-	
-};

Source/SpeckleUnreal/Public/API/Models/SpeckleCommit.h

@@ -1,66 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "SpeckleCommit.generated.h"
-
-/*
-* GraphQL model for Commit data
-* Properties are only when they explicitly requested (through the GraphQL request)
-* see https://github.com/specklesystems/speckle-sharp/blob/main/Core/Core/Api/GraphQL/Models.cs
-*/
-USTRUCT(BlueprintType)
-struct FSpeckleCommit
-{
-	GENERATED_BODY();
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString ID;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Message;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString BranchName;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString AuthorName;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString AuthorId;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString AuthorAvatar;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString CreatedAt;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString SourceApplication;
-	
-    UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models", DisplayName="Referenced Object Id")
-	FString ReferencedObject;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString TotalChildrenCount;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	TArray<FString> Parents;
-	
-};
-
-USTRUCT(BlueprintType)
-struct FSpeckleCommits
-{
-	GENERATED_BODY();
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	int32 TotalCount;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Cursor;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	TArray<FSpeckleCommit> Items;
-};

Source/SpeckleUnreal/Public/API/Models/SpeckleStream.h

@@ -1,78 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "SpeckleBranch.h"
-#include "SpeckleCollaborator.h"
-
-#include "SpeckleStream.generated.h"
-
-/*
-* GraphQL model for Stream data
-* Properties are only when they explicitly requested (through the GraphQL request)
-* see https://github.com/specklesystems/speckle-sharp/blob/main/Core/Core/Api/GraphQL/Models.cs
-*/
-USTRUCT(BlueprintType)
-struct FSpeckleStream 
-{
-	GENERATED_BODY()
-
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models", DisplayName="Stream Id")
-	FString ID;
-
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	FString Name;
-
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	FString Description;
-
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	bool IsPublic;
-
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	FString Role;
-
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	FString	CreatedAt;
-
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	FString UpdatedAt;
-
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	FString FavoritedDate;
-	
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	TArray<FSpeckleCollaborator> Collaborators;
-
-	// Object properties are only set if explicitly requested by a custom GraphQL request
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	FSpeckleBranches Branches;
-
-	// Object properties are only set if explicitly requested by a custom GraphQL request
-	UPROPERTY(BlueprintReadOnly, DisplayName="Branch (Request Only)", Category="Speckle|API Models", AdvancedDisplay)
-	FSpeckleBranch Branch;
-
-	// Object properties are only set if explicitly requested by a custom GraphQL request
-	UPROPERTY(BlueprintReadOnly, DisplayName="Commit (Request Only)", Category="Speckle|API Models", AdvancedDisplay)
-	FSpeckleCommit Commit;
-
-	// Object properties are only set if explicitly requested by a custom GraphQL request
-	UPROPERTY(BlueprintReadOnly, Category="Speckle|API Models")
-	FSpeckleCommits Commits;
-};
-
-USTRUCT(BlueprintType)
-struct FSpeckleStreams
-{
-	GENERATED_BODY();
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	int32 TotalCount;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Cursor;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	TArray<FSpeckleStream> Items;
-};

Source/SpeckleUnreal/Public/API/Models/SpeckleUser.h

@@ -1,45 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "SpeckleStream.h"
-#include "SpeckleUser.generated.h"
-
-/*
-* GraphQL model for User data
-* Properties are only when they explicitly requested (through the GraphQL request)
-* see https://github.com/specklesystems/speckle-sharp/blob/main/Core/Core/Api/GraphQL/Models.cs
-*/
-USTRUCT(BlueprintType)
-struct FSpeckleUser
-{
-	GENERATED_BODY()
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Id;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Email;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Name;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Bio;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Company;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Avatar;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FString Role;
-
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FSpeckleStreams Streams;
-	
-	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
-	FSpeckleStreams FavoriteStreams;
-};

Source/SpeckleUnreal/Public/API/Operations/ReceiveBranchesOperation.h

@@ -0,0 +1,48 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintAsyncActionBase.h"
+#include "Objects/HighLevel/SpeckleBranch.h"
+
+#include "ReceiveBranchesOperation.generated.h"
+
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FReceiveBranchesOperationHandler,
+											const TArray<FSpeckleBranch>&, Branches,
+											const FString&, ErrorMessage);
+
+/**
+ *   Receive All streams	
+ */
+UCLASS()
+class SPECKLEUNREAL_API UReceiveBranchesOperation : public UBlueprintAsyncActionBase
+{
+	GENERATED_BODY()
+	
+public:
+	
+    UPROPERTY(BlueprintAssignable)
+    FReceiveBranchesOperationHandler OnReceiveSuccessfully;
+
+	UPROPERTY(BlueprintAssignable)
+    FReceiveBranchesOperationHandler OnError;
+
+	UFUNCTION(BlueprintCallable, BlueprintInternalUseOnly, Category = "Speckle|Operations", meta = (WorldContext = "WorldContextObject"))
+	static UReceiveBranchesOperation* ReceiveBranchesOperation(UObject* WorldContextObject,
+															const FString& ServerUrl, const FString& AuthToken, const FString& StreamId, int32 Limit = 20);
+	virtual void Activate() override;
+	
+protected:
+	void Request();
+	
+	FString ServerUrl;
+	FString AuthToken;
+	FString StreamId;
+	int32 Limit;
+
+	void HandleReceive(const TArray<FSpeckleBranch>& Branches);
+	
+	void HandleError(const FString& Message);
+};

Source/SpeckleUnreal/Public/API/Operations/ReceiveCommitsOperation.h

@@ -0,0 +1,53 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintAsyncActionBase.h"
+#include "Objects/HighLevel/SpeckleCommit.h"
+
+#include "ReceiveCommitsOperation.generated.h"
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FReceiveCommitsOperationHandler, const TArray<FSpeckleCommit>&, Commits, FString, ErrorMessage);
+
+
+/**
+ *   Receive All Commits	
+ */
+UCLASS()
+class SPECKLEUNREAL_API UReceiveCommitsOperation : public UBlueprintAsyncActionBase
+{
+	GENERATED_BODY()
+	
+public:
+	
+    UPROPERTY(BlueprintAssignable)
+    FReceiveCommitsOperationHandler OnReceiveSuccessfully;
+
+	UPROPERTY(BlueprintAssignable)
+    FReceiveCommitsOperationHandler OnError;
+
+
+	UFUNCTION(BlueprintCallable, BlueprintInternalUseOnly, Category = "Speckle|Operations",
+						meta = (WorldContext = "WorldContextObject", BranchName = "main"))
+	static UReceiveCommitsOperation* ReceiveCommitsOperation(UObject* WorldContextObject,
+																const FString& ServerUrl,
+																const FString& AuthToken,
+																const FString& StreamId,
+																const FString& BranchName,
+																const int32 Limit = 20);
+	virtual void Activate() override;
+	
+protected:
+	void Request();
+	
+	FString ServerUrl;
+	FString AuthToken;
+	FString StreamId;
+	FString BranchName;
+	int32 Limit;
+
+	void HandleReceive(const TArray<FSpeckleCommit>& Commits);
+	
+	void HandleError(const FString& Message);
+};

Source/SpeckleUnreal/Public/API/Operations/ReceiveGlobalsOperation.h

@@ -0,0 +1,48 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintAsyncActionBase.h"
+#include "Objects/HighLevel/SpeckleGlobals.h"
+
+#include "ReceiveGlobalsOperation.generated.h"
+
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FReceiveGlobalsOperationHandler, const FSpeckleGlobals, Globals, FString, ErrorMessage);
+
+
+/**
+ *   Receive My User Data in Speckle
+ */
+UCLASS()
+class SPECKLEUNREAL_API UReceiveGlobalsOperation : public UBlueprintAsyncActionBase
+{
+	GENERATED_BODY()
+	
+public:
+	
+    UPROPERTY(BlueprintAssignable)
+    FReceiveGlobalsOperationHandler OnReceiveSuccessfully;
+
+	UPROPERTY(BlueprintAssignable)
+    FReceiveGlobalsOperationHandler OnError;
+	
+	UFUNCTION(BlueprintCallable, BlueprintInternalUseOnly, Category = "Speckle|Operations", meta = (WorldContext = "WorldContextObject"))
+	static UReceiveGlobalsOperation* ReceiveGlobalsOperation(UObject* WorldContextObject,
+	                                                         const FString& ServerUrl, const FString& AuthToken,
+	                                                         const FString& StreamId, const FString& ReferencedObjectId);
+	virtual void Activate() override;
+
+protected:
+	void Request();
+	
+	FString ServerUrl;
+	FString AuthToken;
+	FString StreamId;
+	FString ReferencedObjectId;
+
+	void HandleReceive(const FSpeckleGlobals& Object);
+	
+	void HandleError(const FString& Message);
+};

Source/SpeckleUnreal/Public/API/Operations/ReceiveMyUserDataOperation.h

@@ -0,0 +1,49 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintAsyncActionBase.h"
+#include "Objects/HighLevel/SpeckleUser.h"
+
+#include "ReceiveMyUserDataOperation.generated.h"
+
+struct FSpeckleUser;
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FReceiveMyUserDataOperationHandler, const FSpeckleUser, MyUserData, FString, ErrorMessage);
+
+
+/**
+ *   Receive My User Data in Speckle
+ */
+UCLASS()
+class SPECKLEUNREAL_API UReceiveMyUserDataOperation : public UBlueprintAsyncActionBase
+{
+	GENERATED_BODY()
+	
+public:
+	
+    UPROPERTY(BlueprintAssignable)
+    FReceiveMyUserDataOperationHandler OnReceiveSuccessfully;
+
+	UPROPERTY(BlueprintAssignable)
+    FReceiveMyUserDataOperationHandler OnError;
+	
+
+	UFUNCTION(BlueprintCallable, BlueprintInternalUseOnly, Category = "Speckle|Operations",
+																meta = (WorldContext = "WorldContextObject"))
+	static UReceiveMyUserDataOperation* ReceiveMyUserDataOperation(UObject* WorldContextObject,
+		const FString& ServerUrl, const FString& AuthToken);
+	
+	virtual void Activate() override;
+	
+protected:
+	void Request();
+	
+	FString ServerUrl;
+	FString AuthToken;
+
+	void HandleReceive(const FSpeckleUser& Object);
+	
+	void HandleError(const FString& Message);
+};

Source/SpeckleUnreal/Public/API/Operations/ReceiveStreamsOperation.h

@@ -0,0 +1,44 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintAsyncActionBase.h"
+#include "Objects/HighLevel/SpeckleStream.h"
+
+#include "ReceiveStreamsOperation.generated.h"
+
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FReceiveStreamsOperationHandler, const TArray<FSpeckleStream>&, Streams, FString, ErrorMessage);
+
+/**
+ *   Receive All streams	
+ */
+UCLASS()
+class SPECKLEUNREAL_API UReceiveStreamsOperation : public UBlueprintAsyncActionBase
+{
+	GENERATED_BODY()
+	
+public:
+	
+    UPROPERTY(BlueprintAssignable)
+    FReceiveStreamsOperationHandler OnReceiveSuccessfully;
+
+	UPROPERTY(BlueprintAssignable)
+    FReceiveStreamsOperationHandler OnError;
+
+	UFUNCTION(BlueprintCallable, BlueprintInternalUseOnly, Category = "Speckle|Operations", meta = (WorldContext = "WorldContextObject"))
+	static UReceiveStreamsOperation* ReceiveStreamsOperation(UObject* WorldContextObject, const FString& ServerUrl, const FString& AuthToken, const int32 Limit = 20);
+	virtual void Activate() override;
+	
+protected:
+	void Request();
+	
+	FString ServerUrl;
+	FString AuthToken;
+	int32 Limit;
+
+	void HandleReceive(const TArray<FSpeckleStream>& Streams);
+	
+	void HandleError(const FString& Message);
+};

Source/SpeckleUnreal/Public/API/Operations/SpeckleStreamAPIOperation.h

@@ -1,63 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Kismet/BlueprintAsyncActionBase.h"
-
-#include "SpeckleStreamAPIOperation.generated.h"
-
-
-DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FAPIResponseHandler, FString, JsonResponse, FString, ErrorMessage);
-
-/**
- * Allows sending GraphQL queries to the Speckle GraphQL API
- * 
- */
-UCLASS()
-class SPECKLEUNREAL_API USpeckleStreamAPIOperation : public UBlueprintAsyncActionBase
-{
-	GENERATED_BODY()
-
-public:
-	
-    UPROPERTY(BlueprintAssignable)
-    FAPIResponseHandler OnReceiveSuccessfully;
-
-	UPROPERTY(BlueprintAssignable)
-    FAPIResponseHandler OnError;
-
-	/**
-	 * Sends an GraphQL queries to a speckle server's "/graphql" endpoint
-	 * E.g. for fetching stream/branch/commit/user info.
-	 *
-	 * @param	ServerUrl				The URL of the Speckle server
-	 * @param	AuthToken				The auth token of the user (optional for unprivilaged requests)
-	 * @param	GraphQlQuery			The GraphQl query (starting with `query{ }`)
-	 * @param	ResponsePropertyName	The name of the root property being requested.  (e.g. for a "query{user{...}" query, then the property name is  "user")
-	 * @param	RequestLogName			A friendly name for this request (logging and analytics) 
-	 */
-	UFUNCTION(BlueprintCallable, BlueprintInternalUseOnly, Category = "Speckle|Operations")
-	static USpeckleStreamAPIOperation* SpeckleStreamAPIOperation(
-		const FString& ServerUrl,
-		const FString& AuthToken,
-		const FString& GraphQlQuery,
-		const FString& ResponsePropertyName,
-		const FString& RequestLogName);
-	
-	virtual void Activate() override;
-	
-protected:
-	void Request();
-	
-	FString ServerUrl;
-	FString AuthToken;
-	FString Query;
-	FString RequestLogName;
-	FString ResponsePropertyName;
-	
-	void HandleReceive(const FString& ResponseJson);
-	
-	void HandleError(const FString& Message);
-
-};

Source/SpeckleUnreal/Public/API/SpeckleAPIFunctions.h

@@ -1,32 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "Kismet/BlueprintFunctionLibrary.h"
-
-#include "SpeckleAPIFunctions.generated.h"
-
-struct FSpeckleCommit;
-/**
- * Blueprint function library for Speckle API 
- */
-UCLASS()
-class SPECKLEUNREAL_API USpeckleAPIFunctions : public UBlueprintFunctionLibrary
-{
-	GENERATED_BODY()
-
-public:
-	
-	UFUNCTION(BlueprintCallable, CustomThunk, Category="Speckle|API", meta=(CustomStructureParam="OutStruct", ExpandBoolAsExecs="ReturnValue"))
-	static UPARAM(DisplayName = "WasSucessful") bool DeserializeResponse(const FString& JsonString, int32& OutStruct);
-	DECLARE_FUNCTION(execDeserializeResponse);
-	
-	static bool GenericDeserializeResponse(const FString& JsonString, const UScriptStruct* StructType, void* OutStruct);
-
-	static void CommitReceived(FSpeckleCommit& Commit);
-
-
-	
-};

Source/SpeckleUnreal/Public/Conversion/SpeckleConverterComponent.h

@@ -4,6 +4,7 @@
 
 #include "CoreMinimal.h"
 #include "Components/ActorComponent.h"
+#include "Objects/HighLevel/SpeckleStream.h"
 
 #include "SpeckleConverterComponent.generated.h"
 
@@ -30,14 +31,29 @@ public:
 	
 	// Sets default values for this component's properties
 	USpeckleConverterComponent();
+
 	
 	// Converts the given Base and all children into native actors.
 	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion")
 	UPARAM(DisplayName = "RootActor") AActor* RecursivelyConvertToNative(AActor* AOwner, const UBase* Base,
 		       const TScriptInterface<ITransport>& LocalTransport, bool DisplayProgressBar, TArray<AActor*>& OutActors);
-		
+
+	
+	// Converts the given Base and all children into native actors.
+	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion")
+	UPARAM(DisplayName = "RootActor") TArray<FSpeckleStream> ConvertStreamsToNative(
+						AActor* AOwner,
+						const UBase* Base,
+						const TScriptInterface<ITransport>& LocalTransport,
+						bool DisplayProgressBar,
+						TArray<AActor*>& OutActors
+						);
+	
 	UFUNCTION(BlueprintCallable, Category="Speckle|Conversion")
 	virtual void FinishConversion();
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle|Conversion")
+	TArray<FSpeckleStream> ArrayOfStreams;
 	
 protected:
 

Source/SpeckleUnreal/Public/Mixpanel.h

@@ -14,8 +14,8 @@ protected:
 	static const FString VersionedApplicationName;
 
 public:
-	static void TrackEvent(const FString& Server, const FString& EventName);
-	static void TrackEvent(const FString& Server, const FString& EventName, const TMap<FString, FString>& CustomProperties);
-	static void TrackEvent(const FString& Email, const FString& Server, const FString& EventName, const TMap<FString, FString>& CustomProperties);
+	static void TrackEvent(const FString& Email, const FString& Server, const FString& EventName);
+	static void TrackEvent(const FString& Email, const FString& Server, const FString& EventName,
+																		const TMap<FString, FString>& CustomProperties);
 	static FString Hash(const FString& Input);
-};
+};

Source/SpeckleUnreal/Public/Objects/Base.h

@@ -13,7 +13,7 @@ class ASpeckleUnrealManager;
 /**
  * Base type that all Object Models inherit from
  */
-UCLASS(BlueprintType, meta=(DisplayName="Base (Speckle.Objects)"))
+UCLASS(BlueprintType)
 class SPECKLEUNREAL_API UBase : public UObject
 {
 public:
@@ -22,7 +22,7 @@ public:
 	
 protected:
 	
-	explicit UBase(const TCHAR* SpeckleType): SpeckleType(FString(SpeckleType)) {}
+	explicit UBase(const wchar_t* SpeckleType): SpeckleType(SpeckleType) {}
 	explicit UBase(const FString& SpeckleType) : SpeckleType(SpeckleType) {}
 	
 public:

Source/SpeckleUnreal/Public/Objects/DisplayValueElement.h

@@ -13,7 +13,7 @@ class UMesh;
 /**
  * 
  */
-UCLASS()
+UCLASS(meta=(ScriptName="Display Value Element (Speckle.Objects)"))
 class SPECKLEUNREAL_API UDisplayValueElement : public UBase
 {
 	GENERATED_BODY()

Source/SpeckleUnreal/Public/Objects/Geometry/Box.h

@@ -0,0 +1,39 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Mesh.h"
+#include "Objects/Base.h"
+#include "Box.generated.h"
+
+class UPlane;
+/**
+ * 
+ */
+UCLASS(meta=(ScriptName="Box (Speckle.Objects)"))
+class SPECKLEUNREAL_API UBoxx : public UBase
+{
+	GENERATED_BODY()
+
+
+public:
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
+	UPlane* BasePlane;
+	
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
+	FVector2f XSize, YSize;
+	
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
+	float Area;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
+	float Volume;
+	
+
+	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport) override;
+
+	UFUNCTION(BlueprintCallable)
+	virtual UMesh* ToMesh(UObject* Outer = GetTransientPackage()) const;
+};

Source/SpeckleUnreal/Public/Objects/Geometry/Mesh.h

@@ -12,7 +12,7 @@ class URenderMaterial;
 /**
  * 
  */
-UCLASS()
+UCLASS(meta=(ScriptName="Mesh (Speckle.Objects)"))
 class SPECKLEUNREAL_API UMesh : public UBase
 {
 	GENERATED_BODY()
@@ -42,10 +42,5 @@ public:
 	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport) override;
 
 protected:
-	
-
-	/// If not already so, this method will align vertices
-	/// such that a vertex and its corresponding texture coordinates have the same index.
-	/// See "https://github.com/specklesystems/speckle-sharp/blob/main/Objects/Objects/Geometry/Mesh.cs"
 	virtual void AlignVerticesWithTexCoordsByIndex();
 };

Source/SpeckleUnreal/Public/Objects/Geometry/Plane.h

@@ -0,0 +1,25 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Objects/Base.h"
+#include "Plane.generated.h"
+
+/**
+ * 
+ */
+UCLASS(meta=(ScriptName="Plane (Speckle.Objects)"))
+class SPECKLEUNREAL_API UPlane : public UBase
+{
+	GENERATED_BODY()
+
+
+public:
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Speckle|Objects")
+	FVector Origin, Normal, XDir, YDir;
+	
+
+	virtual bool Parse(const TSharedPtr<FJsonObject> Obj, const TScriptInterface<ITransport> ReadTransport) override;
+	
+};

Source/SpeckleUnreal/Public/Objects/Geometry/PointCloud.h

@@ -10,7 +10,7 @@
 /**
  * 
  */
-UCLASS()
+UCLASS(meta=(ScriptName="Point Cloud (Speckle.Objects)"))
 class SPECKLEUNREAL_API UPointCloud : public UBase
 {
 	GENERATED_BODY()

Source/SpeckleUnreal/Public/Objects/HighLevel/FSpeckleActivity.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "FSpeckleActivity.generated.h"
+
+/*
+* Struct that holds all the properties required
+* for the User Activities
+* received from GraphQL.
+*/
+USTRUCT(BlueprintType)
+struct FSpeckleActivity
+{
+	GENERATED_USTRUCT_BODY()
+	
+	UPROPERTY(BlueprintReadWrite)
+	FString ActionType;
+
+	UPROPERTY(BlueprintReadWrite)
+	FString Time;
+
+	UPROPERTY(BlueprintReadWrite)
+	FString Message;
+
+	UPROPERTY(BlueprintReadWrite)
+	FString StreamId;
+
+	UPROPERTY(BlueprintReadWrite)
+	FString ResourceType;
+
+	UPROPERTY(BlueprintReadWrite)
+	FString ResourceId;
+
+	UPROPERTY(BlueprintReadWrite)
+	FString Info;
+
+	FSpeckleActivity(){};
+
+	FSpeckleActivity(const FString& ActionType, const FString& Time, const FString& Message,
+		const FString& StreamId, const FString& ResourceType, const FString& ResourceId,
+		const FString& Info):
+		ActionType(ActionType), Time(Time), Message(Message), StreamId(StreamId),
+		ResourceType(ResourceType), ResourceId(ResourceId), Info(Info){}
+};

Source/SpeckleUnreal/Public/Objects/HighLevel/FSpeckleEnum.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "FSpeckleEnum.generated.h"
+
+UENUM()
+enum ESpeckleItemType {Stream, Commit, Branch};

Source/SpeckleUnreal/Public/Objects/HighLevel/SpeckleBranch.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "SpeckleCollaborator.h"
+#include "SpeckleBranch.generated.h"
+
+
+/*
+* Struct that holds all the properties required
+* from a speckle Branch
+* received from GraphQL.
+*/
+USTRUCT(BlueprintType)
+struct FSpeckleBranch
+{
+	GENERATED_BODY()
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString ID;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Name;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Description;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Author;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Commits;
+
+	void DisplayAsString(const FString& msg, const TSharedPtr<FJsonObject> Obj) const
+	{
+		FString OutputString;
+		TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&OutputString);
+		FJsonSerializer::Serialize(Obj.ToSharedRef(), Writer);
+		UE_LOG(LogTemp, Log, TEXT("resulting jsonString from %s -> %s"), *msg, *OutputString);
+	}
+
+	FSpeckleBranch(const TSharedPtr<FJsonObject> Obj)
+	{
+		ensureAlways(Obj->TryGetStringField("id", ID));
+		ensureAlways(Obj->TryGetStringField("name", Name));
+		Obj->TryGetStringField("description", Description);
+	}
+	
+	FSpeckleBranch(){};
+	//
+	// FSpeckleBranch(const FString& ID, const FString& Name, const FString& Description):
+	// 	ID(ID), Name(Name), Description(Description){}
+	//
+	// FSpeckleBranch(const FString& ID, const FString& Name, const FString& Description, const FString& Author, const FString& Commits):
+	// 	ID(ID), Name(Name), Description(Description), Author(Author), Commits(Commits){}
+};

Source/SpeckleUnreal/Public/Objects/HighLevel/SpeckleCollaborator.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "SpeckleCollaborator.generated.h"
+
+/*
+* Struct that holds all the properties required
+* from a Collaborator in a Stream
+* received from GraphQL.
+* See https://github.com/specklesystems/speckle-sharp/blob/main/Core/Core/Api/GraphQL/Models.cs
+*/
+USTRUCT(BlueprintType)
+struct FSpeckleCollaborator
+{
+	GENERATED_BODY()
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Id;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Name;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Role;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Avatar;
+	
+	FSpeckleCollaborator() { }
+
+	FSpeckleCollaborator(const TSharedPtr<FJsonObject> JsonObject)
+	{
+		ensureAlways(JsonObject->TryGetStringField("id", Id));
+		ensureAlways(JsonObject->TryGetStringField("name", Name));
+		JsonObject->TryGetStringField("role", Role);
+		JsonObject->TryGetStringField("avatar", Avatar);
+	}
+	
+	FSpeckleCollaborator(const FString& Id, const FString& Name, const FString& Company, const FString& Role, const FString& Avatar)
+		: Id(Id),
+		Name(Name),
+		Role(Role),
+		Avatar(Avatar)
+	{
+	}
+};

Source/SpeckleUnreal/Public/Objects/HighLevel/SpeckleCommit.h

@@ -0,0 +1,115 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "SpeckleCommit.generated.h"
+
+/*
+* Struct that holds all the properties required
+* from a speckle commit
+* received from GraphQL.
+*/
+USTRUCT(BlueprintType)
+struct FSpeckleCommit
+{
+	GENERATED_BODY()
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString ID;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Message;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString BranchName;
+	
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString AuthorName;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString AuthorId;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString AuthorAvatar;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString CreatedAt;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString SourceApplication;
+	
+    UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString ReferenceObjectID;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString TotalChildrenCount;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	TArray<FString> Parents;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString CommentCount;
+
+
+
+	void DisplayAsString(const FString& msg, const TSharedPtr<FJsonObject> Obj) const
+	{
+		FString OutputString;
+		TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&OutputString);
+		FJsonSerializer::Serialize(Obj.ToSharedRef(), Writer);
+		UE_LOG(LogTemp, Log, TEXT("resulting jsonString from %s -> %s"), *msg, *OutputString);
+	}
+	
+	FSpeckleCommit(){};
+
+	FSpeckleCommit(const TSharedPtr<FJsonValue> CommitAsJSONValue)
+	{
+		TSharedPtr<FJsonObject> obj = CommitAsJSONValue->AsObject();
+		ensureAlways(obj->TryGetStringField("id", ID));
+		obj->TryGetStringField("message", Message);
+		obj->TryGetStringField("branchName", BranchName);
+		obj->TryGetStringField("authorName", AuthorName);
+		obj->TryGetStringField("authorId", AuthorId);
+		obj->TryGetStringField("authorAvatar", AuthorAvatar);
+		obj->TryGetStringField("createdAt", CreatedAt);
+		obj->TryGetStringField("sourceApplication", SourceApplication);
+		obj->TryGetStringField("totalChildrenCount", TotalChildrenCount);
+		ensureAlways(obj->TryGetStringField("referencedObject", ReferenceObjectID));
+		obj->TryGetStringArrayField("parents", Parents);
+		obj->TryGetStringField("commentCount", CommentCount); //TODO is this a prop?
+
+	}
+	
+
+	// FSpeckleCommit(const FString& ReferenceObjectID, const FString& Author, const FString& Message, const FString& BranchName)
+	// : ReferenceObjectID(ReferenceObjectID),
+	// Author(Author),
+	// Message(Message),
+	// BranchName(BranchName)
+	// {
+	// }
+
+	// FSpeckleCommit(const FString& ReferenceObjectID, const FString& AuthorName, const FString& Message, const FString& BranchName,
+	// 	const FString& Id, const FString& SourceApplication, const FString& TotalChildrenCount, const FString& Parents,
+	// 	const FString& AuthorId, const FString& AuthorAvatar, const FString& CreatedAt)
+ //        : ReferenceObjectID(ReferenceObjectID),
+ //          Author(Author),
+ //          Message(Message),
+	// 	  BranchName(BranchName),
+	// 	  ID(Id),
+	// 	  SourceApplication(SourceApplication),
+	// 	  TotalChildrenCount(TotalChildrenCount),
+	// 	  Parents(Parents),
+	// 	  AuthorId(AuthorId),
+	// 	  AuthorAvatar(AuthorAvatar),
+	// 	  CreatedAt(CreatedAt)
+	// {
+	// }
+
+	//Operators overloading
+	
+	// FORCEINLINE bool operator==(const FSpeckleCommit &Other) const
+	// {
+	// 	return ReferenceObjectID == Other.ReferenceObjectID;
+	// }
+};

Source/SpeckleUnreal/Public/Objects/HighLevel/SpeckleGlobals.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "SpeckleGlobals.generated.h"
+
+
+/*
+* Struct that holds all the properties required
+* from a speckle Branch
+* received from GraphQL.
+*/
+USTRUCT(BlueprintType)
+struct FSpeckleGlobals
+{
+	GENERATED_USTRUCT_BODY()
+	
+	UPROPERTY(BlueprintReadWrite)
+	FString ID;
+
+	UPROPERTY(BlueprintReadWrite)
+	FString Region;
+
+	UPROPERTY(BlueprintReadWrite)
+	float Latitude;
+
+	UPROPERTY(BlueprintReadWrite)
+	float Longitude;
+
+	UPROPERTY(BlueprintReadWrite)
+	float Height;
+
+	FSpeckleGlobals(): Latitude(0), Longitude(0), Height(0)
+	{
+	};
+
+
+	FSpeckleGlobals(const TSharedPtr<FJsonObject> GlobalsJSONObject)
+	{
+		ID       = *GlobalsJSONObject->GetStringField("id");
+		//TArray<TSharedPtr<FJsonValue>> RegionAsArray = GlobalsJSONObject->GetArrayField("region");
+		Region = ""; // RegionAsArray[0]->AsString();
+		Latitude = static_cast<float>(GlobalsJSONObject->GetNumberField("Latitude"));
+		Longitude= static_cast<float>(GlobalsJSONObject->GetNumberField("Longitude"));
+		Height   = static_cast<float>(GlobalsJSONObject->GetNumberField("Height"));
+	}
+
+	
+	FSpeckleGlobals(const FString& ID, const FString& Region, float Latitude, float Longitude)
+	: ID(ID),
+	Region(Region),
+	Latitude(Latitude),
+	Longitude(Longitude)
+	{
+	}
+
+
+	
+	FSpeckleGlobals(const FString& ID, const FString& Region, float Latitude, float Longitude, float Height)
+		: ID(ID),
+		  Region(Region),
+		  Latitude(Latitude),
+		  Longitude(Longitude),
+		  Height(Height)	
+	{
+	}
+};

Source/SpeckleUnreal/Public/Objects/HighLevel/SpeckleStream.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "LogSpeckle.h"
+#include "SpeckleCollaborator.h"
+
+#include "SpeckleStream.generated.h"
+
+/*
+* Class that holds all the properties required
+* from a speckle Branch
+* received from GraphQL.
+*/
+USTRUCT(BlueprintType)
+struct FSpeckleStream 
+{
+	GENERATED_BODY()
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString ID;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Name;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Description;
+
+	// UPROPERTY(BlueprintReadWrite)
+	// bool IsStreamPublic;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Role;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString	CreatedAt;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString UpdatedAt;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	TArray<FSpeckleCollaborator> Collaborators;
+
+
+	void DisplayAsString(const FString& msg, const TSharedPtr<FJsonObject> Obj) const
+	{
+		FString OutputString;
+		TSharedRef< TJsonWriter<> > Writer = TJsonWriterFactory<>::Create(&OutputString);
+		FJsonSerializer::Serialize(Obj.ToSharedRef(), Writer);
+		UE_LOG(LogTemp, Log, TEXT("resulting jsonString from %s -> %s"), *msg, *OutputString);
+	}
+	
+	FSpeckleStream(const TSharedPtr<FJsonValue> StreamAsJSONValue)
+	{
+		TSharedPtr<FJsonObject> Obj = StreamAsJSONValue->AsObject();
+		//DisplayAsString("Collaborators insider --->", Obj);
+
+		ensureAlways(Obj->TryGetStringField("id", ID));
+		ensureAlways(Obj->TryGetStringField("name", Name));
+		Obj->TryGetStringField("description", Description);
+		Obj->TryGetStringField("updatedAt", UpdatedAt);
+		Obj->TryGetStringField("createdAt", CreatedAt);
+		Obj->TryGetStringField("role", Role);
+		
+		const TArray<TSharedPtr<FJsonValue>>* CollaboratorsArrJSONValues;
+		Obj->TryGetArrayField("collaborators", CollaboratorsArrJSONValues);
+
+		for (const TSharedPtr<FJsonValue>& c : *CollaboratorsArrJSONValues)
+		{
+			const TSharedPtr<FJsonObject>* o;
+			if(ensure(c->TryGetObject(o)))
+			{
+				FSpeckleCollaborator Collaborator = FSpeckleCollaborator(*o);
+				Collaborators.Add(Collaborator);
+			}
+		}
+		
+	}
+
+	FSpeckleStream(){};
+	//
+	// FSpeckleStream(const FString& ID, const FString& Name, const FString& Description):
+	// 		ID(ID), Name(Name), Description(Description){};
+	//
+	// FSpeckleStream( const FString& ID,
+	// 				const FString& Name,
+	// 				const FString& Description,
+	// 				const bool& IsPublic,
+	// 				const FString& Role,
+	// 				const FString& CreatedAt,
+	// 				const FString& UpdatedAt):
+	// 		ID(ID),
+	// 		Name(Name),
+	// 		Description(Description),
+	// 		IsPublic(IsPublic),
+	// 		Role(Role),
+	// 		CreatedAt(CreatedAt),
+	// 		UpdatedAt(UpdatedAt){}
+};

Source/SpeckleUnreal/Public/Objects/HighLevel/SpeckleUser.h

@@ -0,0 +1,88 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "SpeckleUser.generated.h"
+
+/*
+* Struct that holds all the properties required
+* for a User
+* received from GraphQL.
+*/
+USTRUCT(BlueprintType)
+struct FSpeckleUser
+{
+	GENERATED_BODY()
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Id;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Email;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Name;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Bio;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Company;
+
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Avatar;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Suuid;
+	
+	UPROPERTY(BlueprintReadWrite, Category="Speckle|API Models")
+	FString Role;
+	
+
+	FSpeckleUser(){};
+	
+	FString DisplayAsString(const FString& msg, const TSharedPtr<FJsonObject> Obj) const
+    {
+    		FString OutputString;
+    		TSharedRef<TJsonWriter<>> Writer = TJsonWriterFactory<>::Create(&OutputString);
+    		FJsonSerializer::Serialize(Obj.ToSharedRef(), Writer);
+    		UE_LOG(LogSpeckle, Log, TEXT("resulting jsonString from %s -> %s"), *msg, *OutputString);
+    }
+
+	FSpeckleUser(const TSharedPtr<FJsonObject> MyUserDataJSONObject)
+	{
+		ensureAlways(MyUserDataJSONObject->TryGetStringField("id", Id));
+		MyUserDataJSONObject->TryGetStringField("name", Name);
+		MyUserDataJSONObject->TryGetStringField("company", Company);
+		MyUserDataJSONObject->TryGetStringField("role", Role);
+		MyUserDataJSONObject->TryGetStringField("suuid", Suuid); //TODO Is this a prop?
+		MyUserDataJSONObject->TryGetStringField("email", Email);
+		MyUserDataJSONObject->TryGetStringField("bio", Bio);
+		MyUserDataJSONObject->TryGetStringField("avatar", Avatar);
+
+	}
+
+	
+	//query{user{id,name,email,company,role,suuid,bio,profiles,avatar}}
+	
+	
+	FSpeckleUser(
+				 const FString& Id,
+		         const FString& Email,
+		         const FString& Bio,
+		         const FString& Company,
+		         const FString& Name,
+				 const FString& Avatar,
+		         const FString& Suuid,
+		         const FString& Role)
+				 :
+		Id(Id),
+		Email(Email),
+		Name(Name),
+		Bio(Bio),
+		Company(Company),
+		Avatar(Avatar),
+		Suuid(Suuid),
+		Role(Role)
+	{}
+};

Source/SpeckleUnreal/Public/Objects/Other/BlockInstance.h

@@ -10,7 +10,7 @@
 /**
  * 
  */
-UCLASS()
+UCLASS(meta=(ScriptName="Block Instance (Speckle.Objects)"))
 class SPECKLEUNREAL_API UBlockInstance : public UBase
 {
 	GENERATED_BODY()

Source/SpeckleUnreal/Public/Objects/Other/RenderMaterial.h

@@ -10,7 +10,7 @@
 /**
  * 
  */
-UCLASS()
+UCLASS(meta=(ScriptName="Render Material (Speckle.Objects)"))
 class SPECKLEUNREAL_API URenderMaterial : public UBase
 {
 	GENERATED_BODY()

Source/SpeckleUnreal/Public/Objects/Other/View3D.h

@@ -10,7 +10,7 @@
 /**
  * 
  */
-UCLASS()
+UCLASS(meta=(ScriptName="View3D (Speckle.Objects)"))
 class SPECKLEUNREAL_API UView3D : public UBase
 {
 	GENERATED_BODY()

Source/SpeckleUnreal/Public/Objects/Utils/SpeckleObjectUtils.h

@@ -44,11 +44,6 @@ public:
 	UFUNCTION(BlueprintPure, Category="Speckle/ObjectUtils")
 	static FTransform CreateTransform(UPARAM(ref) const FMatrix& TransformMatrix);
 
-	UFUNCTION(BlueprintCallable, Category="Speckle/ObjectUtils", meta=(CallableWithoutWorldContext, WorldContext="WorldContextObject", DeterminesOutputType="Class", DynamicOutputParam="ReturnValue"))
-	static AActor* SpawnActorInWorld(const UObject* WorldContextObject, const TSubclassOf<AActor> Class, UPARAM(ref) const FTransform& Transform);
-
-	// Helper function to print a json obj to console
-	static FString DisplayAsString(const FString& msg, const TSharedPtr<FJsonObject> Obj);
-	
-	
+	UFUNCTION(BlueprintCallable, Category="Speckle/ObjectUtils")
+	static AActor* SpawnActorInWorld(const TSubclassOf<AActor> Class, UWorld* World, UPARAM(ref) const FTransform& Transform);
 };

Source/SpeckleUnreal/Public/ReceiveSelectionComponent.h

@@ -1,177 +0,0 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
-
-#pragma once
-
-#include "CoreMinimal.h"
-#include "API/Models/SpeckleStream.h"
-
-#include "ReceiveSelectionComponent.generated.h"
-
-/**
- * Actor component for selecting a Speckle Stream + Object
- * Either by Stream Id + Object Id (Object selection mode)
- * Or by Stream + Branch + Commit (Commit selection mode)
- */
-UCLASS(ClassGroup=(Speckle), meta=(BlueprintSpawnableComponent))
-class SPECKLEUNREAL_API UReceiveSelectionComponent : public UActorComponent
-{
-    GENERATED_BODY()
-	
-public:
-
-    // URL of the speckle server 
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle")
-	FString ServerUrl = "https://speckle.xyz";
-	
-	// A Personal Access Token can be created from your Speckle Profile page (Treat tokens like passwords, do not share publicly)
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", meta=(PasswordField=true))
-	FString AuthToken;
-	
-	// Id of the stream to receive from (checkout the stream URL in the Speckle web viewer)
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", meta=(EditCondition="bManualMode", EditConditionHides, DisplayAfter=bManualMode))
-	FString StreamId;
-
-	// Id of the Speckle Object to receive (checkout the properties panel in the Speckle web viewer)
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", meta=(EditCondition="bManualMode", EditConditionHides, DisplayAfter=StreamId))
-	FString ObjectId;
-	
-	/**
-	 * Trys to get the currently selected Commit (Commit selection mode)
-	 * @param OutCommit the selected Commit (if return was true)
-	 * @returns true if a selection was made
-	 */
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-	bool TryGetSelectedCommit(FSpeckleCommit& OutCommit) const;
-
-	/**
-	 * Trys to get the currently selected Branch (Commit selection mode)
-     * @param OutBranch the selected Branch (if return was true)
-     * @returns true if a selection was made
-     */
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-	bool TryGetSelectedBranch(FSpeckleBranch& OutBranch) const;
-
-	/**
-	 * Trys to get the currently selected Stream (Commit selection mode)
-	 * @param OutStream the selected Stream (if return was true)
-	 * @returns true if a selection was made
-	 */
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-	bool TryGetSelectedStream(FSpeckleStream& OutStream) const;
-	
-	/**
-	 * @param OutStatusMessage the current status of the object selection as a human readable string
-	 * @returns true if a complete object selection is made.
-	 */
-	UFUNCTION(BlueprintCallable, Category="Speckle", CallInEditor)
-    bool IsSelectionComplete(FString& OutStatusMessage) const;
-	
-	// Gets the URL of the current selection/partial selection
-	UFUNCTION(BlueprintCallable, Category="Speckle", CallInEditor)
-    FString GetUrl() const;
-	
-	/**
-	 * Launches the URL of the current selection/partial selection using FPlatformProcess
-	 * @returns true if the URL could be launched
-	 */
-	UFUNCTION(BlueprintCallable, Category="Speckle", CallInEditor)
-    void OpenURLInBrowser() const;
-	
-#if WITH_EDITOR
-	virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
-#endif
-
-	virtual void PropertyChangeHandler(const FName& PropertyName);
-	
-protected: //Internal logic for branch/stream/commit fetching and selection
-	
-	// When true, user specifies stream id + object id, when false, user specifies stream + branch + commit
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Transient, Category="Speckle", meta=(DisplayName="Specify by Object Id", DisplayAfter=AuthToken));
-	bool bManualMode = true;
-	
-	// Limit of how many streams/branches/commits to fetch
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", AdvancedDisplay, meta=(DisplayName="Options Limit", ClampMin=0, ClampMax=100, UIMin = 1, UIMax=30))
-	int32 Limit = 15;
-	
-	// Refreshes the Stream/Branch/Commit options
-	UFUNCTION(BlueprintCallable, Category="Speckle", CallInEditor)
-	void Refresh();
-
-#pragma region Stream	
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Transient, Category="Speckle", meta=(DisplayName="Stream", GetOptions=GetStreamsOptions, EditCondition="IsAccountValid && !bManualMode", NoResetToDefault))
-	FString SelectedStreamText;
-	
-	UPROPERTY(BlueprintReadOnly, Transient, Category="Speckle")
-	TMap<FString, FSpeckleStream> Streams;
-
-    UFUNCTION(BlueprintCallable, Category="Speckle")
-	virtual TArray<FString> GetStreamsOptions() const;
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-    bool SelectStream(const FString& DisplayId);
-
-    UFUNCTION(BlueprintCallable, Category="Speckle")
-	virtual void UpdateStreams();
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-	virtual FSpeckleStream GetSelectedStream() const;
-	
-	UPROPERTY(BlueprintReadOnly, Transient, Category="Speckle")
-	bool IsStreamValid = false;
-	
-	UPROPERTY(BlueprintReadOnly, Transient, Category="Speckle")
-	bool IsAccountValid = false;
-
-#pragma endregion
-
-#pragma region Branch
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Transient, Category="Speckle", meta=(DisplayName="Branch", GetOptions=GetBranchOptions, EditCondition="IsStreamValid && !bManualMode", NoResetToDefault))
-	FString SelectedBranchText;
-	
-	UPROPERTY(BlueprintReadOnly, Transient, Category="Speckle")
-	TMap<FString, FSpeckleBranch> Branches;
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-	virtual TArray<FString> GetBranchOptions();
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-    bool SelectBranch(const FString& DisplayId);
-
-    UFUNCTION(BlueprintCallable, Category="Speckle")
-	virtual void UpdateBranches();
-
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-	virtual FSpeckleBranch GetSelectedBranch() const;
-	
-	UPROPERTY(BlueprintReadOnly, Transient, Category="Speckle")
-	bool IsBranchValid = false;
-
-#pragma endregion
-
-#pragma region Commit
-	UPROPERTY(EditAnywhere, BlueprintReadWrite, Transient, Category="Speckle", meta=(DisplayName="Commit", GetOptions=GetCommitOptions, EditCondition="IsCommitValid && !bManualMode", NoResetToDefault))
-	FString SelectedCommitText;
-	
-	UPROPERTY(BlueprintReadOnly, Transient, Category="Speckle")
-	TMap<FString, FSpeckleCommit> Commits;
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-	virtual TArray<FString> GetCommitOptions();
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-    bool SelectCommit(const FString& DisplayId);
-
-    UFUNCTION(BlueprintCallable, Category="Speckle")
-	virtual void UpdateCommits();
-	
-	UFUNCTION(BlueprintCallable, Category="Speckle")
-	virtual FSpeckleCommit GetSelectedCommit() const;
-	
-	UPROPERTY(BlueprintReadOnly, Transient, Category="Speckle")
-	bool IsCommitValid = false;
-
-#pragma endregion
-
-    static void LogError(const FString& Message, const FString LogName);
-};
-

Source/SpeckleUnreal/Public/SpeckleUnrealManager.h

@@ -8,7 +8,6 @@
 class UServerTransport;
 class ITransport;
 class USpeckleConverterComponent;
-class UReceiveSelectionComponent;
 class FJsonObject;
 
 /**
@@ -20,10 +19,20 @@ class SPECKLEUNREAL_API ASpeckleUnrealManager : public AActor
 	GENERATED_BODY()
 	
 public:
-
-	UPROPERTY(VisibleAnywhere, Category="Speckle", BlueprintReadWrite)
-	UReceiveSelectionComponent* ReceiveSelection;
 	
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle")
+	FString ServerUrl;
+	
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle")
+	FString StreamID;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle")
+	FString ObjectID;
+
+	// A Personal Access Token can be created from your Speckle Profile page (Treat tokens like passwords, do not share publicly) - Required for receiving private streams
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", meta=(PasswordField = true))
+	FString AuthToken;
+
 	// When true, will call `Receive` on BeginPlay
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", AdvancedDisplay)
 	bool ImportAtRuntime;
@@ -36,7 +45,7 @@ public:
 	UPROPERTY(VisibleAnywhere, Category="Speckle", BlueprintReadWrite)
 	USpeckleConverterComponent* Converter;
 	
-	// When true, will display an editor progress bar while receiving objects
+	// Used to stagger transport requests, useful when making requests for a large number of child objects
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Speckle", AdvancedDisplay)
 	bool DisplayProgressBar;
 	

Source/SpeckleUnreal/Public/Transports/ServerTransport.h

@@ -4,7 +4,7 @@
 
 #include "CoreMinimal.h"
 #include "Transport.h"
-#include "API/Models/SpeckleStream.h"
+#include "Objects/HighLevel/SpeckleStream.h"
 
 #include "ServerTransport.generated.h"
 
@@ -42,6 +42,24 @@ protected:
 
 	UPROPERTY()
 	int32 MaxNumberOfObjectsPerRequest = 20000;
+
+	UPROPERTY()
+	FString ResponseListOfStreamsSerialized = "";
+
+	UPROPERTY()
+	FString ResponseListOfBranchesSerialized = "";
+
+	UPROPERTY()
+	FString ResponseListOfCommitsSerialized = "";
+
+	UPROPERTY()
+	FString ResponseGlobalsSerialized = "";
+	
+	UPROPERTY()
+	TArray<FSpeckleStream> ArrayOfStreams;
+
+	UPROPERTY()
+	TArray<FSpeckleStream> ArrayOfBranches;
 	
 	FTransportCopyObjectCompleteDelegate OnComplete;
 	FTransportErrorDelegate OnError;
@@ -52,9 +70,9 @@ public:
 
 
 	UFUNCTION(BlueprintPure, Category = "Speckle|Transports")
-	static UServerTransport* CreateServerTransport(const FString& _ServerUrl,
-												   const FString& _StreamId,
-												   const FString& _AuthToken)
+	static UServerTransport* CreateServerTransport(UPARAM(ref) FString& _ServerUrl,
+												   UPARAM(ref)  FString& _StreamId,
+												   UPARAM(ref) FString& _AuthToken)
 	{
 		UServerTransport* Transport = NewObject<UServerTransport>();
 		Transport->ServerUrl = _ServerUrl;
@@ -78,6 +96,10 @@ protected:
 	virtual void HandleRootObjectResponse(const FString& RootObjSerialized,
 										  TScriptInterface<ITransport> TargetTransport,
 										  const FString& ObjectId) const;
+	//
+	// virtual void HandleListOfStreamsResponse(const FString& RootObjSerialized,
+	// 										 TScriptInterface<ITransport> TargetTransport
+	// 										);
 
     /**
 	 * Iteratively fetches chunks of children
@@ -87,7 +109,7 @@ protected:
 	 * @param CStart the index in ChildrenIds of the start point of the current chunk
 	 */
     virtual void FetchChildren(TScriptInterface<ITransport> TargetTransport,
-								const FString& RootObjectId,
+	                            const FString& RootObjectId,
 	                            const TArray<FString>& ChildrenIds,
 	                            int32 CStart = 0) const;
 	

Source/SpeckleUnreal/Public/Transports/Transport.h

@@ -5,11 +5,14 @@
 #include "CoreMinimal.h"
 #include "UObject/Interface.h"
 #include "Dom/JsonObject.h"
+#include "Objects/HighLevel/SpeckleStream.h"
 
 #include "Transport.generated.h"
 
 DECLARE_DELEGATE_OneParam(FTransportCopyObjectCompleteDelegate, TSharedPtr<FJsonObject>);
 DECLARE_DELEGATE_OneParam(FTransportErrorDelegate, FString&);
+DECLARE_DELEGATE_OneParam(FStreamsRequestProcessedDelegate, const TArray<FSpeckleStream>&);
+
 //DECLARE_DELEGATE_OneParam(FTransportTotalChildrenCountKnownDelegate, int32);
 //DECLARE_DELEGATE_OneParam(FTransportProgressDelegate, int32);
 
@@ -28,6 +31,9 @@ class SPECKLEUNREAL_API ITransport
 	GENERATED_BODY()
 
 public:
+
+	
+	FString ResponseListOfStreamsSerialized = "";
 	
  	virtual void SaveObject(const FString& ObjectId, const TSharedPtr<FJsonObject> SerializedObject) = 0;
 

Source/SpeckleUnreal/SpeckleUnreal.Build.cs

@@ -32,7 +32,7 @@ public class SpeckleUnreal : ModuleRules
 				"ProceduralMeshComponent",
 				"MeshDescription",
 				"StaticMeshDescription", 
-				"LidarPointCloudRuntime",
+				"LidarPointCloudRuntime"
 				// ... add other public dependencies that you statically link with here ...
 			}
 		);

Source/SpeckleUnrealEditor/Private/Conversion/ConverterFactory.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Fill out your copyright notice in the Description page of Project Settings.
 
 
 #include "Conversion/ConverterFactory.h"

Source/SpeckleUnrealEditor/Private/SpeckleUnrealEditorModule.cpp

@@ -1,4 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Copyright Epic Games, Inc. All Rights Reserved.
 
 #include "SpeckleUnrealEditorModule.h"
 

Source/SpeckleUnrealEditor/Public/InterfaceClassFilter.h

@@ -1,4 +1,4 @@
-// Copyright 2022 AEC Systems, Licensed under the Apache License, Version 2.0
+// Copyright Epic Games, Inc. All Rights Reserved.
 
 #pragma once
 

SpeckleUnreal.uplugin

@@ -1,14 +1,14 @@
 {
 	"FileVersion": 3,
 	"Version": 1,
-	"VersionName": "2.6.0",
-	"FriendlyName": "Speckle Unreal",
+	"VersionName": "2.5.1",
+	"FriendlyName": "SpeckleUnreal",
 	"Description": "Speckle is an open source data platform for Architecture, Engineering, and Construction. It has been open sourced under the MIT license, is customizable, and available in the cloud or via a self-hosted server. It allows users to exchange data between various AEC modelling and content creation platforms.",
 	"Category": "AEC",
 	"CreatedBy": "Speckle",
 	"CreatedByURL": "https://speckle.systems/",
 	"DocsURL": "https://github.com/specklesystems/speckle-unreal",
-	"MarketplaceURL": "com.epicgames.launcher://ue/marketplace/product/98770ce9d4f143de8dd7882a707a6f81",
+	"MarketplaceURL": "",
 	"SupportURL": "https://speckle.community/",
 	"CanContainContent": true,
 	"IsBetaVersion": true,
@@ -19,7 +19,7 @@
 			"Name": "SpeckleUnreal",
 			"Type": "Runtime",
 			"LoadingPhase": "Default",
-			"WhitelistPlatforms": [ "Win64", "Linux", "Mac" ]
+			"WhitelistPlatforms": [ "Win64", "Linux", "Mac", "IOS", "Android" ]
 		},
 		{
 			"Name": "SpeckleUnrealEditor",