com.rest.blockadelabs 1.0.0 (#7)

- Initial Release! 🎉

Author: StephenHodgson

Documentation~/README.md

@@ -12,7 +12,7 @@ I am not affiliated with BlockadeLabs and an account with api access is required
 
 Requires Unity 2021.3 LTS or higher.
 
-The recommended installation method is though the unity package manager and [OpenUPM](https://openupm.com/packages/com.openai.unity).
+The recommended installation method is though the unity package manager and [OpenUPM](https://openupm.com/packages/com.rest.blockadelabs).
 
 ### Via Unity Package Manager and OpenUPM
 
@@ -35,6 +35,7 @@ The recommended installation method is though the unity package manager and [Ope
 - Add package from git url: `https://github.com/RageAgainstThePixel/com.rest.blockadelabs.git#upm`
   > Note: this repo has dependencies on other repositories! You are responsible for adding these on your own.
   - [com.utilities.async](https://github.com/RageAgainstThePixel/com.utilities.async)
+  - [com.utilities.extensions](https://github.com/RageAgainstThePixel/com.utilities.extensions)
   - [com.utilities.rest](https://github.com/RageAgainstThePixel/com.utilities.rest)
 
 ## Documentation
@@ -46,6 +47,10 @@ The recommended installation method is though the unity package manager and [Ope
   - [Get Skybox Styles](#get-skybox-styles)
   - [Generate Skybox](#generate-skybox)
   - [Get Skybox by Id](#get-skybox)
+  - [Delete Skybox by Id](#delete-skybox)
+  - [Get Skybox History](#get-skybox-history)
+  - [Cancel Skybox Generation](#cancel-skybox-generation)
+  - [Cancel All Pending Skybox Generations](#cancel-all-pending-skybox-generations)
 
 ### Authentication
 
@@ -108,7 +113,7 @@ var api = new BlockadeLabsClient(BlockadeLabsAuthentication.Default.LoadFromEnvi
 
 ### Skyboxes
 
-#### [Get Skybox Styles](https://blockade.cloudshell.run/redoc#tag/skybox/operation/Get_Skybox_Styles_api_v1_skybox_styles_get)
+#### [Get Skybox Styles](https://api-documentation.blockadelabs.com/api/skybox.html#get-skybox-styles)
 
 Returns the list of predefined styles that can influence the overall aesthetic of your skybox generation.
 
@@ -122,23 +127,73 @@ foreach (var skyboxStyle in skyboxStyles)
 }
 ```
 
-#### [Generate Skybox](https://blockade.cloudshell.run/redoc#tag/skybox/operation/Generate_Skybox_api_v1_skybox_generate_post)
+#### [Generate Skybox](https://api-documentation.blockadelabs.com/api/skybox.html#generate-skybox)
 
-Generate a skybox image
+Generate a skybox.
 
 ```csharp
 var api = new BlockadeLabsClient();
-var request = new SkyboxRequest("underwater", depth: true);
+var request = new SkyboxRequest("mars", depth: true);
 var skyboxInfo = await api.SkyboxEndpoint.GenerateSkyboxAsync(request);
 skyboxMaterial.mainTexture = skyboxInfo.MainTexture;
 skyboxMaterial.depthTexture = skyboxInfo.DepthTexture;
 ```
 
-#### [Get Skybox](https://blockade.cloudshell.run/redoc#tag/skybox/operation/Get_Skybox_By_Id_api_v1_skybox_info__id__get)
+#### [Get Skybox](https://api-documentation.blockadelabs.com/api/skybox.html#get-skybox-by-id)
 
 Returns the skybox metadata for the given skybox id.
 
 ```csharp
-var skyboxInfo = await api.SkyboxEndpoint.GetSkyboxInfoAsync("skybox-id");
+var skyboxId = 42;
+var skyboxInfo = await api.SkyboxEndpoint.GetSkyboxInfoAsync(skyboxId);
 Debug.Log($"Skybox: {result.Id} | {result.MainTextureUrl}");
+// Note: If you wish to use the returned skybox textures you'll need to additionally call await SkyboxInfo.LoadTexturesAsync(); before you can assign them to a material property.
+await skyboxInfo.LoadTexturesAsync();
+skyboxMaterial.mainTexture = skyboxInfo.MainTexture;
+skyboxMaterial.depthTexture = skyboxInfo.DepthTexture;
+```
+
+#### [Delete Skybox](https://api-documentation.blockadelabs.com/api/skybox.html#delete)
+
+Deletes a skybox by id.
+
+```csharp
+var skyboxId = 42;
+var result = await api.SkyboxEndpoint.DeleteSkyboxAsync(skybox);
+// result == true
+```
+
+#### [Get Skybox History](https://api-documentation.blockadelabs.com/api/skybox.html#get-history)
+
+Gets the previously generated skyboxes.
+
+```csharp
+var history = await api.SkyboxEndpoint.GetSkyboxHistoryAsync();
+Debug.Log($"Found {history.TotalCount} skyboxes");
+
+foreach (var skybox in history.Skyboxes)
+{
+    Debug.Log($"{skybox.Id} {skybox.Title} status: {skybox.Status}");
+}
+```
+
+#### [Cancel Skybox Generation](https://api-documentation.blockadelabs.com/api/skybox.html#cancel-generation)
+
+Cancels a pending skybox generation request by id.
+
+```csharp
+var skyboxId = 42;
+var result = await CancelSkyboxGenerationAsync(skyboxId);
+// result == true
+```
+
+> Note: This is automatically done when cancelling a skybox generation using cancellation token.
+
+#### [Cancel All Pending Skybox Generations](https://api-documentation.blockadelabs.com/api/skybox.html#cancel-all-pending-generations)
+
+Cancels ALL pending skybox generation requests.
+
+```csharp
+var result = await api.SkyboxEndpoint.CancelAllPendingSkyboxGenerationsAsync();
+Debug.Log(result ? "All pending generations successfully cancelled" : "No pending generations");
 ```

Runtime/BlockadeLabsAuthInfo.cs

@@ -1,3 +1,5 @@
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
 using System;
 using System.Security.Authentication;
 using UnityEngine;

Runtime/BlockadeLabsBaseEndpoint.cs

@@ -1,3 +1,5 @@
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
 using Utilities.WebRequestRest;
 
 namespace BlockadeLabs

Runtime/BlockadeLabsConfiguration.cs

@@ -1,3 +1,5 @@
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
 using UnityEngine;
 using Utilities.WebRequestRest.Interfaces;
 

Runtime/BlockadeLabsSettings.cs

@@ -1,3 +1,5 @@
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
 using System.Linq;
 using UnityEngine;
 using Utilities.WebRequestRest.Interfaces;

Runtime/BlockadeLabsSettingsInfo.cs

@@ -1,3 +1,5 @@
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
 using System;
 using Utilities.WebRequestRest.Interfaces;
 

Runtime/Skyboxes/SkyboxEndpoint.cs

@@ -29,6 +29,28 @@ public SkyboxInfoRequest([JsonProperty("request")] SkyboxInfo skyboxInfo)
             public SkyboxInfo SkyboxInfo { get; }
         }
 
+        [Preserve]
+        private class SkyboxOperation
+        {
+            [Preserve]
+            [JsonConstructor]
+            public SkyboxOperation(
+                [JsonProperty("success")] string success,
+                [JsonProperty("error")] string error)
+            {
+                Success = success;
+                Error = error;
+            }
+
+            [Preserve]
+            [JsonProperty("success")]
+            public string Success { get; }
+
+            [Preserve]
+            [JsonProperty("Error")]
+            public string Error { get; }
+        }
+
         public SkyboxEndpoint(BlockadeLabsClient client) : base(client) { }
 
         protected override string Root => string.Empty;
@@ -40,8 +62,7 @@ public SkyboxEndpoint(BlockadeLabsClient client) : base(client) { }
         /// <returns>A list of <see cref="SkyboxStyle"/>s.</returns>
         public async Task<IReadOnlyList<SkyboxStyle>> GetSkyboxStylesAsync(CancellationToken cancellationToken = default)
         {
-            var endpoint = GetUrl("skybox/styles");
-            var response = await Rest.GetAsync(endpoint, parameters: new RestParameters(client.DefaultRequestHeaders), cancellationToken);
+            var response = await Rest.GetAsync(GetUrl("skybox/styles"), parameters: new RestParameters(client.DefaultRequestHeaders), cancellationToken);
             response.Validate();
             return JsonConvert.DeserializeObject<IReadOnlyList<SkyboxStyle>>(response.Body, client.JsonSerializationOptions);
         }
@@ -102,39 +123,36 @@ public async Task<SkyboxInfo> GenerateSkyboxAsync(SkyboxRequest skyboxRequest, i
 
             while (!cancellationToken.IsCancellationRequested)
             {
-                await Task.Delay(pollingInterval ?? 3 * 1000, cancellationToken)
+                await Task.Delay(pollingInterval ?? 3 * 1000, CancellationToken.None)
                     .ConfigureAwait(true); // Configure await to make sure we're still in Unity context
-                skyboxInfo = await GetSkyboxInfoAsync(skyboxInfo, cancellationToken);
+                skyboxInfo = await GetSkyboxInfoAsync(skyboxInfo, CancellationToken.None);
 
-                if (skyboxInfo.Status is "pending" or "processing")
+                if (skyboxInfo.Status is Status.Pending or Status.Processing or Status.Dispatched)
                 {
                     continue;
                 }
 
                 break;
             }
 
-            if (skyboxInfo.Status != "complete")
+            if (cancellationToken.IsCancellationRequested)
             {
-                throw new Exception($"Failed to generate skybox! {skyboxInfo.Id} -> {skyboxInfo.Status}\nError: {skyboxInfo.ErrorMessage}\n{skyboxInfo}");
+                var cancelResult = await CancelSkyboxGenerationAsync(skyboxInfo, CancellationToken.None);
+
+                if (!cancelResult)
+                {
+                    throw new Exception($"Failed to cancel generation for {skyboxInfo.Id}");
+                }
             }
 
-            var downloadTasks = new List<Task>(2)
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (skyboxInfo.Status != Status.Complete)
             {
-                Task.Run(async () =>
-                {
-                    skyboxInfo.MainTexture = await Rest.DownloadTextureAsync(skyboxInfo.MainTextureUrl, parameters: null, cancellationToken: cancellationToken);
-                }, cancellationToken),
-                Task.Run(async () =>
-                {
-                    if (!string.IsNullOrWhiteSpace(skyboxInfo.DepthTextureUrl))
-                    {
-                        skyboxInfo.DepthTexture = await Rest.DownloadTextureAsync(skyboxInfo.DepthTextureUrl, parameters: null, cancellationToken: cancellationToken);
-                    }
-                }, cancellationToken)
-            };
-
-            await Task.WhenAll(downloadTasks);
+                throw new Exception($"Failed to generate skybox! {skyboxInfo.Id} -> {skyboxInfo.Status}\nError: {skyboxInfo.ErrorMessage}\n{skyboxInfo}");
+            }
+
+            await skyboxInfo.LoadTexturesAsync(cancellationToken);
             return skyboxInfo;
         }
 
@@ -150,5 +168,85 @@ public async Task<SkyboxInfo> GetSkyboxInfoAsync(int id, CancellationToken cance
             response.Validate();
             return JsonConvert.DeserializeObject<SkyboxInfoRequest>(response.Body, client.JsonSerializationOptions).SkyboxInfo;
         }
+
+        /// <summary>
+        /// Deletes a skybox by id.
+        /// </summary>
+        /// <param name="id">The id of the skybox.</param>
+        /// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
+        /// <returns>True, if skybox was successfully deleted.</returns>
+        public async Task<bool> DeleteSkyboxAsync(int id, CancellationToken cancellationToken = default)
+        {
+            var response = await Rest.DeleteAsync(GetUrl($"imagine/deleteImagine/{id}"), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
+            response.Validate();
+            var skyboxOp = JsonConvert.DeserializeObject<SkyboxOperation>(response.Body, client.JsonSerializationOptions);
+
+            const string successStatus = "Item deleted successfully";
+
+            if (skyboxOp is not { Success: successStatus })
+            {
+                throw new Exception($"Failed to cancel generation for skybox {id}!\n{skyboxOp?.Error}");
+            }
+
+            return skyboxOp.Success.Equals(successStatus);
+        }
+
+        /// <summary>
+        /// Gets the previously generated skyboxes.
+        /// </summary>
+        /// <param name="parameters">Optional, <see cref="SkyboxHistoryParameters"/>.</param>
+        /// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
+        /// <returns><see cref="SkyboxHistory"/>.</returns>
+        public async Task<SkyboxHistory> GetSkyboxHistoryAsync(SkyboxHistoryParameters parameters = null, CancellationToken cancellationToken = default)
+        {
+            var historyRequest = parameters ?? new SkyboxHistoryParameters();
+            var response = await Rest.GetAsync(GetUrl($"imagine/myRequests{historyRequest}"), parameters: new RestParameters(client.DefaultRequestHeaders), cancellationToken);
+            response.Validate();
+            return JsonConvert.DeserializeObject<SkyboxHistory>(response.Body, client.JsonSerializationOptions);
+        }
+
+        /// <summary>
+        /// Cancels a pending skybox generation request by id.
+        /// </summary>
+        /// <param name="id">The id of the skybox.</param>
+        /// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
+        /// <returns>True, if generation was cancelled.</returns>
+        public async Task<bool> CancelSkyboxGenerationAsync(int id, CancellationToken cancellationToken = default)
+        {
+            var response = await Rest.DeleteAsync(GetUrl($"imagine/requests/{id}"), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
+            response.Validate();
+            var skyboxOp = JsonConvert.DeserializeObject<SkyboxOperation>(response.Body, client.JsonSerializationOptions);
+
+            if (skyboxOp is not { Success: "true" })
+            {
+                throw new Exception($"Failed to cancel generation for skybox {id}!\n{skyboxOp?.Error}");
+            }
+
+            return skyboxOp.Success.Equals("true");
+        }
+
+        /// <summary>
+        /// Cancels ALL pending skybox generation requests.
+        /// </summary>
+        /// <param name="cancellationToken">Optional, <see cref="CancellationToken"/>.</param>
+        public async Task<bool> CancelAllPendingSkyboxGenerationsAsync(CancellationToken cancellationToken = default)
+        {
+            var response = await Rest.DeleteAsync(GetUrl("imagine/requests/pending"), new RestParameters(client.DefaultRequestHeaders), cancellationToken);
+            response.Validate();
+            var skyboxOp = JsonConvert.DeserializeObject<SkyboxOperation>(response.Body, client.JsonSerializationOptions);
+
+            if (skyboxOp is not { Success: "true" })
+            {
+                if (skyboxOp != null &&
+                    skyboxOp.Error.Contains("You don't have any pending"))
+                {
+                    return false;
+                }
+
+                throw new Exception($"Failed to cancel all pending skybox generations!\n{skyboxOp?.Error}");
+            }
+
+            return skyboxOp.Success.Equals("true");
+        }
     }
 }

Runtime/Skyboxes/SkyboxHistory.cs

@@ -0,0 +1,30 @@
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace BlockadeLabs.Skyboxes
+{
+    public sealed class SkyboxHistory
+    {
+        [JsonConstructor]
+        public SkyboxHistory(
+            [JsonProperty("data")] List<SkyboxInfo> skyboxes,
+            [JsonProperty("totalCount")] int totalCount,
+            [JsonProperty("has_more")] bool hasMore)
+        {
+            Skyboxes = skyboxes;
+            TotalCount = totalCount;
+            HasMore = hasMore;
+        }
+
+        [JsonProperty("data")]
+        public IReadOnlyList<SkyboxInfo> Skyboxes { get; }
+
+        [JsonProperty("totalCount")]
+        public int TotalCount { get; }
+
+        [JsonProperty("has_more")]
+        public bool HasMore { get; }
+    }
+}