Kinectify.SDK 2.0.3

Kinectify C# SDK

The Kinectify C# SDK is a library that allows Kinectify customers to integrate with our public-facing APIs. The SDK is implemented in C# and targets .NET 8.0 and .NET 7.

Requirements

• .NET 8.0 SDK or .NET 7.0 SDK
• Visual Studio 2019 or later
• An active Kinectify account

Configuration

The SDK requires some configuration to work properly. The configuration is represented by the KinectifyConfiguration class. Here are the configuration options:

• TenantType: The type of the tenant.
• TenantId: The ID of the tenant.
• Jurisdiction: The jurisdiction.
• Authorization: The authorization configuration.
• TestMode: A flag indicating whether the SDK is in test mode.
• KinectifyDomain: The domain of Kinectify.
• PlayerHashSalt: The salt used to hash the player for verification of imports.

You can provide these configuration options through the appsettings.json file in your project or through environment variables.

Usage

Install the Kinectify SDK Package

You can install the package through NuGet using the following command: 
```bash
    dotnet add package Kinectify.SDK --version 1.0.11
```

Setup your configuration

Kinectify recommends setting up the configuration using either your appsettings.json file or environment variables. The solution is intended to work with the default IConfiguration system in C#.

Add the following to your appsettings.json file:

{
    ...,
    "Kinectify": {
        "TenantType": "<YOUR_TENANT_TYPE>",
        "TenantId": "<YOUR_TENANT_ID>",
        "PlayerHashSalt": "<YOUR_PLAYER_HASHSALT>",
        "Jurisdiction": "..",
        "Authorization": {
            "ClientId": "<YOUR_CLIENT_ID>",
            "ClientSecret": "<YOUR_CLIENT_SECRET>",
            "Domain": "...",
            "Audience": "...",
            "Scopes": "...",
            "GrantType": "..."
        },
        "TestMode": "true",
        "KinectifyDomain": "..."
    }
}

Contact your Implementation Specialist to get these values

Register Kinectify resources

You need to register Kinectify resources in your dependency injection container. Kinectify provides an extension method to make this very easy:

var builder = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .AddJsonFile($"appsettings{environment}.json", true, true)
    .AddEnvironmentVariables();

IConfiguration configuration = builder.Build();

var services = new ServiceCollection();

services.UseKinectifyClient(configuration); // This extension method registers the Kinectify SDK services with the IServiceCollection interface.
var provider = services.BuildServiceProvider(); // we will use this in our examples below, but you would most likely be using an AppBuilder and other injection tools

Create a Player

Kinectify recommends using constructor injection to inject the PlayerClient into your class. However, the example below shows how to use IServiceProvider to retrieve the PlayerClient and send a player to Kinectify.

var playerClient = provider.GetService<PlayerClient>();

// Create a Player
var playerId = "{Your Unique ID for a player}";
Player player = new()
{
    PlayerId = playerId,
    Name = new()
    {
        FirstName = "John",
        LastName = "Doe"
    },
    Email = "john.doe@gmail.com",
};

await playerClient.CreateAsync(player);

Validate Player Data

In some cases, you may want to run a check on a handful of players to ensure they have been ingested into the Kinectify Platform. DO NOT run this method on every player or every time you call the CreateAsync method. It is intended for spot checking purposed during implementation, not for regular use after integration. This method will confirm the player data that you provide matches the player data in Kinectify.

var playerId = "{Your Unique ID for a player}";
Player player = new()
{
    PlayerId = playerId,
    Name = new()
    {
        FirstName = "John",
        LastName = "Doe"
    },
    Email = "john.doe@gmail.com",
};
var isMatching = await playerClient.VerifyPlayer(player);

Create a Transaction

Kinectify recommends using constructor injection to to inject the TransactionClient into your class, but in this examples we will use one from the IServiceProvider. Make sure you followed Step 3 above to register the Kinectify clients into your IServiceProvider.

var transactionClient = provider.GetService<TransactionClient>();
// Create a Transaction
PlayerTransaction transaction = new()
{
    PropertyCode = "RPC",
    TransactionType = TransactionType.Transaction,
    Direction = Direction.Out,
    ExternalTransactionId = Guid.NewGuid().ToString(),
    PlayerExternalId = playerId, // This is your unique ID for the player (rewards number, internal player id, etc.)
    Amount = 100,
    TransactionDate = DateTime.Now,
    GameDate = DateTime.Now,
    SourceInstrument = new BaseInstrument
    {
        InstrumentType = InstrumentType.Cash,
        InstrumentNumber = "123456",
        Currency = "USD",
        Nationality = Nationality.Domestic,
        Country = "US",
        Purpose = "Test",
    },
    TargetInstrument = new BaseInstrument
    {
        InstrumentType = InstrumentType.Cash,
        InstrumentNumber = "123456",
        Currency = "USD",
        Nationality = Nationality.Domestic,
        Country = "US",
        Purpose = "Test",
    },
    ManuallyCreated = false,
    PlayerName = null // you don't have to provide this data, the Kinectify system will enrich your transaction object automatically
};

await transactionClient.CreateAsync(transaction);

Create Gaming Activity

Creating Gaming Activity (Wagers, Wins, and Losses) is just like creating a transaction.

    PlayerGamingActivity gamingActivity = new()
    {
        PropertyCode = "RPC",
        GameType = "Poker",
        ActivityCode = ActivityCode.WAGER,
        Instrument = new BaseInstrument
        {
            InstrumentType = InstrumentType.Chips,
            InstrumentNumber = "123456",
            Currency = "USD",
            Nationality = Nationality.Domestic,
            Country = "US",
        },
        TransactionType = TransactionType.GamingActivity,
        ExternalTransactionId = Guid.NewGuid().ToString(),
        Code = TransactionCode.Gameplay,
        PlayerExternalId = playerId, // This is the player ID that was created in the previous step.
        PlayerName = null,
        Location = "Case 1",
        Amount = 1922,
        GameDate = DateTime.Now,
        TransactionDate = DateTime.Now,
        IsSar = false,
        ManuallyCreated = false,
    };

    await gamingActivityClient.CreateAsync(gamingActivity);

Bulk Operations

The Kinectify API supports creating players, transactions, and gaming activity in bulk. The bulk endpoints can process ~50trx per second, so expect it 20 seconds to finish all 1000 objects below.

    var bulk = new BulkTransactionImportModel
    {
        Transactions = [ // an array of up to 500 transaction objects
            transaction
        ],
        GamingActivities = [ // an array of up to 500 gaming activity objects
            gamingActivity
        ]
    };

    await bulkTransactionClient.CreateAsync(bulk);

// bulk importing players
List<PlayerImport> playerImport =
[
    new()
    {
        PlayerId = Guid.NewGuid().ToString(),
        Name = new()
        {
            FirstName = "John",
            LastName = "Doe2"
        },
        Email = "john.doe2@gmail.com"
    },

    new()
    {
        PlayerId = Guid.NewGuid().ToString(),
        Name = new()
        {
            FirstName = "John",
            LastName = "Doe3"
        },
        Email = "john.doe2@gmail.com",
    }
]; // this array should not exceed 100 players
await playerImportClient.MassImport(playerImport);