Pixelbin 2.0.0

Pixelbin Backend SDK for C#

Pixelbin Backend SDK for C# helps you integrate the core Pixelbin features with your application.

Getting Started

Getting started with Pixelbin Backend SDK for C#

Installation

dotnet add package pixelbin

Usage

Quick Example

using System;
using System.Collections.Generic;
using System.IO;

// import the Pixelbin Platform Namespace
using Pixelbin.Platform;

namespace ExampleNamespace
{
    class ExampleClass
    {
        async void Main(string[] args)
        {
            // Create a config with your API_TOKEN
            PixelbinConfig config = new PixelbinConfig(
                new Dictionary<string, string>() {
                    { "domain", "https://api.pixelbin.io" },
                    { "apiSecret", "API_TOKEN" }
                });

            // Create a pixelbin instance
            PixelbinClient pixelbin = new PixelbinClient(config);

            // List the assets stored on your organization's Pixelbin Storage
            try
            {
                var result = pixelbin.assets.listFiles();
                Console.WriteLine(result);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
    }
}

Uploader

upload

Uploads a file to PixelBin with greater control over the upload process.

Arguments

Returns

dict: On success, returns a dictionary containing the details of the uploaded file.

Example Usage

Uploading a Buffer

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Pixelbin.Platform;
using static Pixelbin.Platform.Enums;

namespace PixelbinUploaderTest
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Create a config with your API_TOKEN
            var config = new PixelbinConfig(
                new Dictionary<string, string> {
                    { "domain", "https://api.pixelbin.io" },
                    { "apiSecret", "API_TOKEN" }
                };
            );
            var pixelbin = new PixelbinClient(config);
            var assets = new Assets(config);
            var uploader = new Uploader(assets);

            var filePath = Path.Combine(AppContext.BaseDirectory, "myimage.png");

            // Read the file into a buffer
            var buffer = await File.ReadAllBytesAsync(filePath);

            try
            {
                var resultBuffer = await uploader.Upload(
                    buffer,
                    "myimage",
                    "folder",
                    "png",
                    AccessEnum.PUBLIC_READ,
                    new List<string> { "test" },
                    new Dictionary<string, object>(),
                    false,
                    true,
                    1500,
                    new UploadOptions
                    {
                        ChunkSize = 5 * 1024 * 1024,   // 5MB
                        Concurrency = 2,               // 2 concurrent chunk uploads
                        MaxRetries = 1,                // 1 retry for errors that can be retried
                        ExponentialFactor = 2          // Exponential factor for retries
                    }
                );

                Console.WriteLine(JsonConvert.SerializeObject(resultBuffer));
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

Uploading a Stream

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Pixelbin.Platform;
using static Pixelbin.Platform.Enums;

namespace PixelbinUploaderTest
{
    class Program
    {
        static async Task Main(string[] args)
        {
            // Create a config with your API_TOKEN
            var config = new PixelbinConfig(
                new Dictionary<string, string> {
                    { "domain", "https://api.pixelbin.io" },
                    { "apiSecret", "API_TOKEN" }
                };
            );
            var pixelbin = new PixelbinClient(config);
            var assets = new Assets(config);
            var uploader = new Uploader(assets);

            var filePath = Path.Combine(AppContext.BaseDirectory, "myimage.png");

            // Open the file as a stream
            var stream = new MemoryStream(buffer);

            try
            {
                var resultStream = await uploader.Upload(
                    stream,
                    "myimage",
                    "folder",
                    "png",
                    AccessEnum.PUBLIC_READ,
                    new List<string> { "test" },
                    new Dictionary<string, object>(),
                    false,
                    true,
                    1500,
                    {
                        ChunkSize = 5 * 1024 * 1024,   // 5MB
                        Concurrency = 2,               // 2 concurrent chunk uploads
                        MaxRetries = 1,                // 1 retry for errors that can be retried
                        ExponentialFactor = 2          // Exponential factor for retries
                    }
                );

                Console.WriteLine("Upload using stream successful!");
                Console.WriteLine(JsonConvert.SerializeObject(resultStream));
            }
            catch (Exception ex)
            {
                Console.WriteLine("Upload using stream failed:");
                Console.WriteLine(ex.Message);
            }
        }
    }
}

Security Utils

For generating Signed URLs

Generate a signed PixelBin url

Example:

using Pixelbin.Security;

namespace ExampleNamespace
{
    class ExampleClass
    {
        void Main(string[] args)
        {
            string signedUrl = Security.SignURL(
                "https://cdn.pixelbin.io/v2/dummy-cloudname/original/__playground/playground-default.jpeg", // url
                20, // expirySeconds
                "0b55aaff-d7db-45f0-b556-9b45a6f2200e", // accessKey
                "dummy-token" // token
            );
            // signedUrl
            // https://cdn.pixelbin.io/v2/dummy-cloudname/original/__playground/playground-default.jpeg?pbs=8eb6a00af74e57967a42316e4de238aa88d92961649764fad1832c1bff101f25&pbe=1695635915&pbt=0b55aaff-d7db-45f0-b556-9b45a6f2200e
        }
    }
}

Usage with custom domain url

using Pixelbin.Security;

namespace ExampleNamespace
{
    class ExampleClass
    {
        void Main(string[] args)
        {
            string signedUrl = Security.SignURL(
                "https://krit.imagebin.io/v2/original/__playground/playground-default.jpeg", // url
                30, // expirySeconds
                "0b55aaff-d7db-45f0-b556-9b45a6f2200e", // accessKey
                "dummy-token" // token
            );
            // signedUrl
            // https://krit.imagebin.io/v2/original/__playground/playground-default.jpeg?pbs=1aef31c1e0ecd8a875b1d3184f324327f4ab4bce419d81d1eb1a818ee5f2e3eb&pbe=1695705975&pbt=0b55aaff-d7db-45f0-b556-9b45a6f2200e
        }
    }
}

URL Utils

Pixelbin provides url utilities to construct and deconstruct Pixelbin urls.

url_to_obj

Deconstruct a pixelbin url

Returns:

Example:

using System;
using System.Collections.Generic;
using System.IO;
using Pixelbin.Utils;

namespace ExampleNamespace
{
    class ExampleClass
    {
        void Main(string[] args)
        {
            string pixelbinUrl = "https://cdn.pixelbin.io/v2/your-cloud-name/z-slug/t.resize(h:100,w:200)~t.flip()/path/to/image.jpeg?dpr=2.0&f_auto=True";

            UrlObj obj = Url.UrlToObj(pixelbinUrl);
            // returned obj schema when serialized to json
            // {
            //     "cloudName": "your-cloud-name",
            //     "zone": "z-slug",
            //     "version": "v2",
            //     "options": {
            //         "dpr": 2.0,
            //         "f_auto": True,
            //     },
            //     "transformations": [
            //         {
            //             "plugin": "t",
            //             "name": "resize",
            //             "values": [
            //                 {
            //                     "key": "h",
            //                     "value": "100"
            //                 },
            //                 {
            //                     "key": "w",
            //                     "value": "200"
            //                 }
            //             ]
            //         },
            //         {
            //             "plugin": "t",
            //             "name": "flip",
            //         }
            //     ],
            //     "filePath": "path/to/image.jpeg",
            //     "baseUrl": "https://cdn.pixelbin.io"
            // }
        }
    }
}

obj_to_url

Converts the extracted url obj to a Pixelbin url.

using System;
using System.Collections.Generic;
using System.IO;
using Pixelbin.Utils;

namespace ExampleNamespace
{
    class ExampleClass
    {
        void Main(string[] args)
        {
            UrlObj obj = new UrlObj (
                version: "v2",
                cloudName: "your-cloud-name",
                filePath: "path/to/image.jpeg",
                options: new UrlObjOptions() {
                    dpr: 2.0,
                    f_auto: true
                },
                zone: "z-slug",
                baseUrl: "https://cdn.pixelbin.io",
                transformations: new List<UrlTransformation>() {
                    new UrlTransformation(
                        plugin: "t",
                        name: "resize",
                        values: new List<Dictionary<string, string>>() {
                            new Dictionary<string, string>() { { "key", "h" }, { "value", "200" } },
                            new Dictionary<string, string>() { { "key", "w" }, { "value", "200" } }
                        }
                    ),
                    new UrlTransformation(
                        plugin: "t",
                        name: "flip"
                    )
                }
            );

            string url = obj_to_url(obj)
            // returned url string
            // https://cdn.pixelbin.io/v2/your-cloud-name/z-slug/t.resize(h:100,w:200)~t.flip()/path/to/image.jpeg?dpr=2.0&f_auto=True
        }
    }
}

Documentation

• API docs