### Installing OpenAPI.NET Package (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Demonstrates how to install the required NuGet package for the OpenAPI.NET library within a .NET interactive notebook environment using the `#r` directive. This is the first step to make the library available for use in the script.

```C#
#r "nuget: Spotware.OpenAPI.Net"
```

--------------------------------

### Install preview SignalR client - Bash

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/lib/microsoft/signalr/README.md

Provides command-line instructions using npm or yarn to install the next preview version of the @microsoft/signalr package. Use this to try out upcoming features before they are officially released.

```bash
npm install @microsoft/signalr@next
# or
yarn add @microsoft/signalr@next
```

--------------------------------

### Installing SignalR Client Preview via npm/yarn (Bash)

Source: https://github.com/spotware/openapi.net/blob/master/samples/ASP.NET.Sample/wwwroot/lib/microsoft/signalr/README.md

Installs the latest preview version of the @microsoft/signalr JavaScript/TypeScript client library using the `next` tag on npm/yarn. This allows users to test upcoming features or fixes before they are officially released.

```Bash
npm install @microsoft/signalr@next
# or
yarn add @microsoft/signalr@next
```

--------------------------------

### Installing OpenAPI.NET NuGet Package (PowerShell)

Source: https://github.com/spotware/openapi.net/blob/master/docs/index.md

This command is used in the NuGet Package Manager Console within Visual Studio or equivalent .NET development environments to add the Spotware.OpenAPI.Net library as a dependency to your project. It fetches the package from Nuget.org.

```PowerShell
Install-Package Spotware.OpenAPI.Net
```

--------------------------------

### Installing SignalR Client Stable via npm/yarn (Bash)

Source: https://github.com/spotware/openapi.net/blob/master/samples/ASP.NET.Sample/wwwroot/lib/microsoft/signalr/README.md

Installs the latest stable release of the @microsoft/signalr JavaScript/TypeScript client library using either npm or yarn package managers. This is the standard method to add the client dependency to your project.

```Bash
npm install @microsoft/signalr
# or
yarn add @microsoft/signalr
```

--------------------------------

### Sample Credentials Configuration (JSON)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Provides an example structure for a `credentials.json` file used to store API authentication details. It includes placeholders for the application's client ID, secret, and a user's access token obtained from the cTrader Open API site.

```JSON
{
  "ClientId": "your app client id",
  "Secret": "your app secret",
  "AccessToken": "your access token, create one by using your app playground on open API site"
}
```

--------------------------------

### Connecting to SignalR Hub (JavaScript NodeJS)

Source: https://github.com/spotware/openapi.net/blob/master/samples/ASP.NET.Sample/wwwroot/lib/microsoft/signalr/README.md

Illustrates how to use the @microsoft/signalr client in a Node.js application. It demonstrates requiring the package, building a connection, setting up an event listener, and starting the connection to interact with a SignalR hub.

```JavaScript
const signalR = require("@microsoft/signalr");

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chat")
    .build();

connection.on("send", data => {
    console.log(data);
});

connection.start()
    .then(() => connection.invoke("send", "Hello"));
```

--------------------------------

### Connect to SignalR Hub - JavaScript Node.js

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/lib/microsoft/signalr/README.md

Demonstrates initializing a SignalR HubConnection in Node.js by requiring the library, setting up a listener for 'send' messages, starting the connection, and invoking a 'send' method. Requires installing the @microsoft/signalr package via npm or yarn.

```javascript
const signalR = require("@microsoft/signalr");

let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chat")
    .build();

connection.on("send", data => {
    console.log(data);
});

connection.start()
    .then(() => connection.invoke("send", "Hello"));
```

--------------------------------

### Install latest SignalR client - Bash

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/lib/microsoft/signalr/README.md

Provides command-line instructions using npm or yarn to install the current stable release of the @microsoft/signalr package. This is the standard way to add the library to your project for use in Node.js or bundling for the browser.

```bash
npm install @microsoft/signalr
# or
yarn add @microsoft/signalr
```

--------------------------------

### Connecting to SignalR Hub (JavaScript Browser)

Source: https://github.com/spotware/openapi.net/blob/master/samples/ASP.NET.Sample/wwwroot/lib/microsoft/signalr/README.md

Demonstrates how to create a HubConnection in a browser environment, configure the target URL and message handlers, and start the connection to send data. Requires including the SignalR browser script via a <script> tag.

```JavaScript
let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chat")
    .build();

connection.on("send", data => {
    console.log(data);
});

connection.start()
    .then(() => connection.invoke("send", "Hello"));
```

--------------------------------

### Creating New Trading Orders (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Defines an asynchronous method `CreateNewOrder` for placing trading orders (Market, Limit, Stop) using the `ProtoOANewOrderReq` message. It includes parameters for order type, volume, trade side, and price for limit/stop orders, sending the request via the authorized client. Examples demonstrate placing market, limit, and stop buy orders.

```C#
public async Task CreateNewOrder(ProtoOAOrderType orderType, long volume, ProtoOATradeSide tradeSide, double limitPrice = 0, double stopPrice = 0)
{
    var request = new ProtoOANewOrderReq
    {
        CtidTraderAccountId = (long)account.CtidTraderAccountId,
        SymbolId = symbol.SymbolId,
        Volume = volume,
        TradeSide = tradeSide,
        OrderType = orderType
    };

    if (request.OrderType == ProtoOAOrderType.Limit)
    {
        request.LimitPrice = limitPrice;
    }

    if (request.OrderType == ProtoOAOrderType.Stop)
    {
        request.StopPrice = stopPrice;
    }

    using var client = await GetClient(account.IsLive ? Mode.Live : Mode.Demo);

    await AuthorizeAccount(client, accountId);

    await client.SendMessage(request, request.PayloadType);

    await Task.Delay(1000);
}

// First market order, change the volume if it doesn't match symbol min volume
// Volume is in units * 100, so 1000 units equal 100000
await CreateNewOrder(ProtoOAOrderType.Market, 100000, ProtoOATradeSide.Buy);
// Limit order, change the price based on current symbol price
await CreateNewOrder(ProtoOAOrderType.Limit, 100000, ProtoOATradeSide.Buy, limitPrice: 1.5);
// Stop order, change the price based on current symbol price
await CreateNewOrder(ProtoOAOrderType.Stop, 100000, ProtoOATradeSide.Buy, stopPrice: 1.5);
```

--------------------------------

### Connect to SignalR Hub - JavaScript Browser

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/lib/microsoft/signalr/README.md

Demonstrates initializing a SignalR HubConnection in a browser using a relative URL, setting up a listener for 'send' messages, starting the connection, and invoking a 'send' method. Requires the SignalR client library to be loaded via a <script> tag on the page.

```javascript
let connection = new signalR.HubConnectionBuilder()
    .withUrl("/chat")
    .build();

connection.on("send", data => {
    console.log(data);
});

connection.start()
    .then(() => connection.invoke("send", "Hello"));
```

--------------------------------

### Getting Open Orders and Positions (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Defines an asynchronous method `GetOrdersAndPositions` to fetch the current state of open orders and positions for the authorized account using the `ProtoOAReconcileReq` message. It's noted that this request is primarily for initial synchronization, and updates should ideally be handled via execution events.

```C#
private async Task<ProtoOAReconcileRes> GetOrdersAndPositions()
{
    var request = new ProtoOAReconcileReq()
    {
        CtidTraderAccountId = (long)account.CtidTraderAccountId,
    };

    ProtoOAReconcileRes result = null;

    void OnResponse(ProtoOAReconcileRes response) => result = response;

    using var client = await GetClient(account.IsLive ? Mode.Live : Mode.Demo);

    await AuthorizeAccount(client, accountId);

    client.OfType<ProtoOAReconcileRes>().Subscribe(OnResponse);

    await client.SendMessage(request, request.PayloadType);

    await Task.Delay(1000);

    if (result is null) throw new InvalidOperationException($"Couldn't get response");

    return result;
}

var ordersAndPositions = await GetOrdersAndPositions();

Console.WriteLine(ordersAndPositions)
```

--------------------------------

### Handling Raw ProtoMessages and Client IDs (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Explains how to subscribe to the low-level ProtoMessage stream, which is necessary to access the ClientMsgId or process messages the client couldn't parse. It shows the subscription using OfType<ProtoMessage>() and provides an example handler method (OnProtoMessage) that retrieves the client message ID and attempts to get the actual message object using MessageFactory.

```C#
var disposable = client.OfType<ProtoMessage>().Subscribe(OnProtoMessage);

private void OnProtoMessage(ProtoMessage protoMessage)
{
	var clientMsgId = protoMessage.ClientMsgId;
	// Message factory can return null
	var message = MessageFactory.GetMessage(protoMessage);
}
```

--------------------------------

### Connect to SignalR Hub - JavaScript WebWorker

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/lib/microsoft/signalr/README.md

Demonstrates initializing a SignalR HubConnection in a WebWorker using an absolute URL, setting up a listener for 'send' messages, starting the connection, and invoking a 'send' method. Requires importing the SignalR client library using importScripts and using an absolute hub URL.

```javascript
importScripts('signalr.js');

let connection = new signalR.HubConnectionBuilder()
    .withUrl("https://example.com/signalr/chat")
    .build();

connection.on("send", data => {
    console.log(data);
});

connection.start()
    .then(() => connection.invoke("send", "Hello"));
```

--------------------------------

### Creating and Authenticating OpenAPI Client (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Defines an asynchronous method `GetClient` that initializes an `OpenClient` instance, subscribes to error events, performs application authentication using the loaded credentials (ClientId, Secret), and waits for the `ProtoOAApplicationAuthRes` response before returning the authenticated client. This sets up the basic connection and validates the application.

```C#
using System.Reactive.Linq;
using Google.Protobuf;

private async Task<OpenClient> GetClient(Mode mode)
{
    var host = ApiInfo.GetHost(mode);

    var client = new OpenClient(host, ApiInfo.Port, TimeSpan.FromSeconds(15));

    client.Subscribe(_ => {}, exception => Console.WriteLine($"Exception: {exception}"));
    client.OfType<ProtoErrorRes>().Subscribe(error => Console.WriteLine($"Exception: {error}"));

    bool isAppAuthroized = false;

    void OnAppAuthorized(ProtoOAApplicationAuthRes response) => isAppAuthroized = true;
    
    client.OfType<ProtoOAApplicationAuthRes>().Subscribe(OnAppAuthorized);
    
    await client.Connect();
    
    var applicationAuthReq = new ProtoOAApplicationAuthReq
    {
        ClientId = credentials.ClientId,
        ClientSecret = credentials.Secret,
    };
    
    await client.SendMessage(applicationAuthReq, applicationAuthReq.PayloadType);

    var waitStartTime = DateTime.Now;

    while (isAppAuthroized is false && DateTime.Now - waitStartTime < TimeSpan.FromSeconds(2))
    {
        await Task.Delay(100);
    }

    if (isAppAuthroized is false) throw new InvalidOperationException("Account authorization failed");

    return client;
}
```

--------------------------------

### Compiling Proto Files with Protoc Shell

Source: https://github.com/spotware/openapi.net/blob/master/docs/compiling-proto-files.md

This command uses the Protobuf compiler (`protoc`) to compile a single `.proto` definition file into a C# source file (`.cs`). The `--csharp_out=.` flag specifies that the output C# file should be generated in the current directory. This command needs to be executed individually for each `.proto` file you wish to compile.

```Shell
protoc --csharp_out=. ./proto_file_name.proto
```

--------------------------------

### Connecting to SignalR Hub (JavaScript WebWorker)

Source: https://github.com/spotware/openapi.net/blob/master/samples/ASP.NET.Sample/wwwroot/lib/microsoft/signalr/README.md

Shows how to initialize the SignalR client and establish a connection within a WebWorker. Note that connecting from a WebWorker requires providing an absolute URL to the SignalR hub.

```JavaScript
importScripts('signalr.js');

let connection = new signalR.HubConnectionBuilder()
    .withUrl("https://example.com/signalr/chat")
    .build();

connection.on("send", data => {
    console.log(data);
});

connection.start()
    .then(() => connection.invoke("send", "Hello"));

```

--------------------------------

### Importing Required Namespaces (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Imports the necessary namespaces from the OpenAPI.Net library, System.Reactive.Linq, System.Linq, and Google.Protobuf to enable client functionality, reactive extensions, LINQ queries, and protobuf message handling.

```C#
using OpenAPI.Net;
using OpenAPI.Net.Auth;
using OpenAPI.Net.Helpers;
using System.Reactive.Linq;
using System.Linq;
using Google.Protobuf;
```

--------------------------------

### Initializing OpenClient (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Initializes a new instance of the OpenClient. It requires the API host URL (obtained from ApiInfo based on live/demo mode), the API port, and a TimeSpan for heartbeat intervals. Optional parameters allow setting the maximum requests per second and choosing between TCP and WebSocket connections.

```C#
// Mode can be either live or demo
// If you want to access and work with live
// trading accounts then use live otherwise use demo
var host = ApiInfo.GetHost(mode);
// You can set the maximum number of requests clients should send per second by using maxRequestPerSecond parameter (default: 40)
// If you want to use web socket instead of TCP socket pass true for useWebSocket parameter of constructor
// web socket allows you to use the Open API on static server-less sites like Blazor WASM environment 
var client = new OpenClient(host, ApiInfo.Port, TimeSpan.FromSeconds(10));
```

--------------------------------

### Loading API Credentials (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Defines a C# record type `Credentials` to hold API key details and an asynchronous method `GetCredentials` to read and deserialize these credentials from a local `credentials.json` file using `System.Text.Json`. This loads the necessary authentication data into memory.

```C#
using System.Text.Json;
using System.Text.Json.Serialization;
using System.IO;

public record Credentials(string ClientId, string Secret, string AccessToken);

private async Task<Credentials> GetCredentials()
{
    using var stream = File.OpenRead("credentials.json");
    return  await JsonSerializer.DeserializeAsync<Credentials>(stream);
}

var credentials = await GetCredentials();

Console.WriteLine(credentials);
```

--------------------------------

### Importing OpenAPI.NET Namespaces (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Includes the necessary namespaces from the OpenAPI.NET library to access its classes and functionalities. These usings are required to reference types like OpenClient, authentication helpers, and protobuf messages.

```C#
using OpenAPI.Net;
using OpenAPI.Net.Auth;
using OpenAPI.Net.Helpers;
```

--------------------------------

### Importing OpenAPI.NET Namespaces (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/authentication.md

Includes the required using directives for accessing classes and methods related to Open API functionality, authentication, and helper utilities within a C# project. These namespaces contain classes like App, TokenFactory, Scope, etc., used throughout the authentication process.

```C#
using OpenAPI.Net;
using OpenAPI.Net.Auth;
using OpenAPI.Net.Helpers;
```

--------------------------------

### Generating Spotware Auth URI using OpenAPI.NET (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/authentication.md

This snippet demonstrates initializing an App object with the application ID, secret, and redirect URL. It then calls GetAuthUri to generate the URL the user needs to open in a browser to log in and authorize the application, optionally specifying the requested scope (e.g., Trading). The generated URI includes parameters required for the authorization server.

```C#
// The classes used in this code snippet are located at OpenAPI.Net.Auth
// Your API application ID
    var appId = "";
// Your API application secret
    var appSecret = ""; 
// One of your API applications redirect URI that you want to redirect user
    var redirectUrl = "";
    _app = new App(appId, appSecret, redirectUrl); 
// The scope of authentication token (Trading or Accounts), Trading is default
    var authUri = _app.GetAuthUri(scope: Scope.Trading);
// authUri is the authentication URI, open it on browser
    System.Diagnostics.Process.Start("explorer.exe", $"\"{authUri}\"");
```

--------------------------------

### Configuring Open API Credentials (JSON)

Source: https://github.com/spotware/openapi.net/blob/master/samples/ASP.NET.Sample/README.md

This JSON snippet shows the structure for the `appsettings-dev.json` file used to store Open API application credentials. The application reads these values to authenticate with the Open API service. It requires the `appsettings-dev.json` file to be present in the project root directory.

```json
{
  "ApiCredentials": {
    "ClientId": "your-application-client-id",
    "Secret": "your-application-client-secret"
  }
}
```

--------------------------------

### Generating Spotware Access Token using OpenAPI.NET (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/authentication.md

After obtaining the authentication code from the redirect URL, this code snippet uses the static TokenFactory.GetToken method to asynchronously request an access token. It requires the authentication code and the previously initialized App object as parameters. The returned token object contains the access token, refresh token, expiry information, and potential error details.

```C#
// The classes used in this code snippet are located at OpenAPI.Net.Auth
// Use TokenFactory to get the token
    var token = await TokenFactory.GetToken(authCode, app);
```

--------------------------------

### Using OpenClient with 'using var' (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Shows a concise way to use the OpenClient with the C# 8 'using var' syntax. This also ensures the client is disposed automatically when the scope in which 'client' is declared is exited.

```C#
using var client = new OpenClient(host, ApiInfo.Port, TimeSpan.FromSeconds(10));
await client.Connect();
```

--------------------------------

### Linking Open Iconic Foundation Font CSS HTML

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Instructs how to include the Open Iconic webfont stylesheet specifically designed for Foundation integration. Add this `<link>` tag to your HTML document's head section.

```HTML
<link href="/open-iconic/font/css/open-iconic-foundation.css" rel="stylesheet">
```

--------------------------------

### Fetching Symbol Data by Name (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Defines an asynchronous method `GetSymbol` to retrieve detailed information for a trading symbol by its name using the `ProtoOASymbolsListReq` message. It requires an authorized client and account, sends the request, filters the response by symbol name, and returns the `ProtoOALightSymbol` object.

```C#
// Be sure your trading account has a symbol with this name,
// if not change it to another symbol name
const string SymbolName = "EURUSD";

private async Task<ProtoOALightSymbol> GetSymbol(string symbolName)
{
    var request = new ProtoOASymbolsListReq
    {
        CtidTraderAccountId = (long)account.CtidTraderAccountId,
    };

    ProtoOALightSymbol result = null;

    void OnResponse(ProtoOASymbolsListRes response)
    {
        result = response.Symbol.FirstOrDefault(symbol => symbol.SymbolName.Equals(SymbolName, StringComparison.OrdinalIgnoreCase));
    }

    using var client = await GetClient(account.IsLive ? Mode.Live : Mode.Demo);

    await AuthorizeAccount(client, accountId);

    client.OfType<ProtoOASymbolsListRes>().Subscribe(OnResponse);

    await client.SendMessage(request, request.PayloadType);

    await Task.Delay(1000);

    if (result is null) throw new InvalidOperationException($"Couldn't get/find the symbol {SymbolName}");

    return result;
}

var symbol = await GetSymbol(SymbolName);
Console.WriteLine(symbol);
```

--------------------------------

### Authorizing Trading Account (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Defines an asynchronous method `AuthorizeAccount` that performs authorization for a specific trading account using its ID and the access token via a `ProtoOAAccountAuthReq` message. This step is necessary before sending any requests specific to a trading account.

```C#
private async Task<ProtoOAAccountAuthRes> AuthorizeAccount(OpenClient client, long accountId)
{
    var request = new ProtoOAAccountAuthReq()
    {
        AccessToken = credentials.AccessToken,
        CtidTraderAccountId = accountId
    };

    ProtoOAAccountAuthRes result = null;

    void OnResponse(ProtoOAAccountAuthRes response) => result = response;
    
    client.OfType<ProtoOAAccountAuthRes>().Subscribe(OnResponse);

    await client.SendMessage(request, request.PayloadType);

    await Task.Delay(500);

    if (result is null) throw new InvalidOperationException($"Couldn't get response");

    return result;
}
```

--------------------------------

### Using OpenClient in a Using Block (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Demonstrates how to wrap the OpenClient creation and usage within a C# 'using' block. This ensures the client's Dispose method is called automatically when the block is exited, releasing resources and closing the connection gracefully.

```C#
using (var client = new OpenClient(host, ApiInfo.Port, TimeSpan.FromSeconds(10))
{
	await client.Connect();
	
	// Send message or subscribe to responses here
}
```

--------------------------------

### Retrieving Authorized Accounts (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Defines an asynchronous method `GetAccounts` to retrieve a list of trading accounts associated with the authorized access token by sending a `ProtoOAGetAccountListByAccessTokenReq` message. It utilizes the previously created client and waits for the corresponding response, returning the list of accounts.

```C#
// Please set one of the authorized trading accounts number
// We will use it for future requests
const long AccountNumber = 3397885;

if (AccountNumber == 0) throw new InvalidOperationException("Please first set the account number");

private async Task<ProtoOAGetAccountListByAccessTokenRes> GetAccounts()
{
    var request = new ProtoOAGetAccountListByAccessTokenReq()
    {
        AccessToken = credentials.AccessToken
    };

    ProtoOAGetAccountListByAccessTokenRes result = null;

    void OnResponse(ProtoOAGetAccountListByAccessTokenRes response) => result = response;

    using var client = await GetClient(Mode.Live);

    client.OfType<ProtoOAGetAccountListByAccessTokenRes>().Subscribe(OnResponse);

    await client.SendMessage(request, request.PayloadType);

    await Task.Delay(1000);

    if (result is null) throw new InvalidOperationException($"Couldn't get response");

    return result;
}

var accounts = await GetAccounts();

var account = accounts.CtidTraderAccount.First(account => account.TraderLogin == AccountNumber);

Console.WriteLine($"Account ID is: {account.CtidTraderAccountId}");
```

--------------------------------

### Using Open Iconic with Foundation Font HTML

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Shows the HTML markup for displaying an Open Iconic icon when using the Foundation-compatible webfont stylesheet. Apply the specific icon class (`fi-icon-name`) to a `<span>` element.

```HTML
<span class="fi-icon-name" title="icon name" aria-hidden="true"></span>
```

--------------------------------

### Linking Open Iconic Bootstrap Font CSS HTML

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Instructs how to include the Open Iconic webfont stylesheet specifically designed for Bootstrap integration. Add this `<link>` tag to your HTML document's head section.

```HTML
<link href="/open-iconic/font/css/open-iconic-bootstrap.css" rel="stylesheet">
```

--------------------------------

### Using Open Iconic Default Font HTML

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Shows the HTML markup for displaying an Open Iconic icon when using the default webfont stylesheet. Apply the `oi` base class and use the `data-glyph` attribute to specify the icon name on a `<span>` element.

```HTML
<span class="oi" data-glyph="icon-name" title="icon name" aria-hidden="true"></span>
```

--------------------------------

### Connecting OpenClient (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Connects the initialized OpenClient instance to the cTrader Open API server asynchronously. This method must be called after creating the client instance before sending or receiving messages. It may throw a ConnectionException if the connection fails or an ObjectDisposedException if the client is already disposed.

```C#
await client.Connect();
```

--------------------------------

### Linking Open Iconic Default Font CSS HTML

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Instructs how to include the default Open Iconic webfont stylesheet when not using Bootstrap or Foundation. Add this `<link>` tag to your HTML document's head section.

```HTML
<link href="/open-iconic/font/css/open-iconic.css" rel="stylesheet">
```

--------------------------------

### Calculating Symbol Bid/Ask from Spot Event C#

Source: https://github.com/spotware/openapi.net/blob/master/docs/calculating-symbol-tick-value.md

Calculates the actual bid and ask prices from the relative values provided in a `ProtoOASpotEvent`. This requires the `ProtoOASymbol` entity for context and utilizes the `GetPriceFromRelative` extension method from the `OpenAPI.Net.Helpers` namespace.

```C#
using OpenAPI.Net.Helpers;
// spotEvent is ProtoOASpotEvent
if (spotEvent.HasBid) bid = symbol.GetPriceFromRelative((long)spotEvent.Bid);
if (spotEvent.HasAsk) ask = symbol.GetPriceFromRelative((long)spotEvent.Ask);
```

--------------------------------

### Using Open Iconic SVG Sprite HTML

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Shows how to display an icon from the Open Iconic SVG sprite using the `<svg>` and `<use>` tags. The `xlink:href` attribute points to the sprite file and the specific icon ID. Recommended practice includes adding general and specific classes for styling.

```HTML
<svg class="icon">
  <use xlink:href="open-iconic.svg#account-login" class="icon-account-login"></use>
</svg>
```

--------------------------------

### Retrieving Historical Trend Bars (C#)

Source: https://github.com/spotware/openapi.net/blob/master/samples/Notebook.Sample/notebook.ipynb

Defines an asynchronous method `GetTrendbars` to fetch historical price data (trend bars) for a specific symbol and time range using the `ProtoOAGetTrendbarsReq` message. It requires an authorized client, account, symbol ID, and start/end timestamps, and returns the `ProtoOAGetTrendbarsRes` containing the requested data.

```C#
private async Task<ProtoOAGetTrendbarsRes> GetTrendbars(long symbolId, DateTimeOffset from, DateTimeOffset to)
{
    var request = new ProtoOAGetTrendbarsReq()
    {
        Period = ProtoOATrendbarPeriod.D1,
        CtidTraderAccountId = (long)account.CtidTraderAccountId,
        SymbolId = symbolId,
        FromTimestamp = from.ToUnixTimeMilliseconds(),
        ToTimestamp = to.ToUnixTimeMilliseconds()
    };

    ProtoOAGetTrendbarsRes result = null;

    void OnResponse(ProtoOAGetTrendbarsRes response) => result = response;

    using var client = await GetClient(account.IsLive ? Mode.Live : Mode.Demo);

    await AuthorizeAccount(client, accountId);

    client.OfType<ProtoOAGetTrendbarsRes>().Subscribe(OnResponse);

    await client.SendMessage(request, request.PayloadType);

    await Task.Delay(1000);

    if (result is null) throw new InvalidOperationException($"Couldn't get response");

    return result;
}

// We get one year of daily bars
var trendbars = await GetTrendbars(symbol.SymbolId, DateTimeOffset.UtcNow.AddYears(-1), DateTimeOffset.UtcNow);

Console.WriteLine(trendbars)
```

--------------------------------

### Embedding Open Iconic SVG Directly HTML

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Demonstrates how to use an Open Iconic icon as a standard SVG image directly in an HTML document. Simply reference the SVG file path using the `<img>` tag.

```HTML
<img src="/open-iconic/svg/icon-name.svg" alt="icon name">
```

--------------------------------

### Subscribing to Spot Events with OpenAPI.NET C#

Source: https://github.com/spotware/openapi.net/blob/master/docs/calculating-symbol-tick-value.md

Subscribes the client to receive `ProtoOASpotEvent` messages, which are triggered whenever a subscribed symbol's bid or ask price changes. This is a prerequisite for obtaining the latest price data needed for tick value calculation.

```C#
client.OfType<ProtoOASpotEvent>().Subscribe(OnSpotEvent);
```

--------------------------------

### Sending Application Authentication Request (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Illustrates sending the mandatory ProtoOAApplicationAuthReq message to authenticate your application with the API. It involves creating the message object with ClientId and ClientSecret, specifying its payload type, and optionally including a client message ID using the SendMessage method.

```C#
// The first message you must send
var applicationAuthReq = new ProtoOAApplicationAuthReq
{
    ClientId = "",
	ClientSecret = "",
};

await _client.SendMessage(applicationAuthReq,
	ProtoOAPayloadType.ProtoOaApplicationAuthReq,
	"This is client message ID and its optional");
```

--------------------------------

### Using Open Iconic with Bootstrap Font HTML

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Shows the HTML markup for displaying an Open Iconic icon when using the Bootstrap-compatible webfont stylesheet. Apply the `oi` base class and the specific icon class (`oi-icon-name`) to a `<span>` element.

```HTML
<span class="oi oi-icon-name" title="icon name" aria-hidden="true"></span>
```

--------------------------------

### Subscribing to All Messages (Excluding Heartbeats) (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Demonstrates subscribing to the OpenClient's message stream using Reactive Extensions (RX). It filters out ProtoHeartbeatEvent messages and subscribes to all others, providing handlers for receiving messages (OnMessageReceived) and handling errors (OnError). The returned IDisposable object is used to unsubscribe.

```C#
// Here I'm filtering out the ProtoHeartbeatEvent and subscribing
// to all other message types
// The OnError will be called if something went wrong
var disposable = client.Where(iMessage =>  iMessage is not ProtoHeartbeatEvent)
	.Subscribe(OnMessageReceived, OnError);
```

--------------------------------

### Subscribing to a Specific Message Type (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Shows how to use the RX Linq OfType extension method to subscribe only to messages of a specific type, such as ProtoOAErrorRes. This simplifies handling particular response or event messages without needing manual type checking. The returned IDisposable object manages the subscription.

```C#
// Here I'm subscribing to only ProtoOAErrorRes
var disposable = client.OfType<ProtoOAErrorRes>().Subscribe(OnError);
```

--------------------------------

### Calculating Symbol Tick Value with OpenAPI.NET Helpers C#

Source: https://github.com/spotware/openapi.net/blob/master/docs/calculating-symbol-tick-value.md

Calculates the symbol's tick value in the account's deposit currency using the `GetTickValue` extension method. It checks if a currency conversion is needed and finds the appropriate conversion symbol and its current price if necessary, passing all required data to the helper method.

```C#
using OpenAPI.Net.Helpers;

double symbolTickValue = 0;

if (symbolQuoteAsset.AssetId == accountDepositAsset.AssetId)
{
	symbolTickValue = symbol.GetTickValue(symbolQuoteAsset, accountDepositAsset, null, default);
}
else
{
	var conversionSymbol = Symbols.FirstOrDefault(iSymbol => (iSymbol.BaseAssetId == symbolQuoteAsset.AssetId
		|| iSymbol.QuoteAssetId == symbolQuoteAsset.AssetId)
		&& (iSymbol.BaseAssetId == accountDepositAsset.AssetId
		|| iSymbol.QuoteAssetId == accountDepositAsset.AssetId));

	if (conversionSymbol is not null && conversionSymbol.Bid is not 0)
	{
		var conversionSymbolBaseAsset = accountAssets.First(iAsset => iAsset.AssetId == conversionSymbol.BaseAssetId);
		
		symbolTickValue = symbol.GetTickValue(symbolQuoteAsset, accountDepositAsset, conversionSymbolBaseAsset, conversionSymbol.Bid);
	}
}
```

--------------------------------

### Subscribing to Client Stream Errors (C#)

Source: https://github.com/spotware/openapi.net/blob/master/docs/open-client.md

Demonstrates how to subscribe specifically to errors occurring within the client's message stream using the Subscribe method's error handler parameter. This allows catching exceptions like ReceiveException or ObserverException that indicate connection issues or errors during message processing by a subscriber. A triggered error handler means the stream is terminated.

```C#
// Here I'm subscribing to only ProtoOAErrorRes
var disposable = client.Subscribe(_ => {}, OnError);
```

--------------------------------

### Coloring Open Iconic SVG Sprite Icons CSS

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Illustrates how to change the color of an icon used via the SVG sprite. This is achieved by setting the `fill` property on the `<use>` tag that references the specific icon.

```CSS
.icon-account-login {
  fill: #f00;
}
```

--------------------------------

### Sizing Open Iconic SVG Sprite Icons CSS

Source: https://github.com/spotware/openapi.net/blob/master/samples/Blazor.WebSocket.Sample/wwwroot/css/open-iconic/README.md

Provides CSS to control the size of icons when using the SVG sprite method. Since icons are square, setting equal `width` and `height` on the parent `<svg>` tag determines the display size.

```CSS
.icon {
  width: 16px;
  height: 16px;
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.