Tutorial

User registration

To create a Customer account, several fields are mandatory:

Name	Details
firstname	String - User firstname to create the account
lastname	String - User lastname to create the account
email	String - Email to identify the account (unique value)
password	String - Password to login User (automaticaly hashed)
id_country	Integer - Country used for invoicing

Retrieve countries

First of all, we have to retrieve the Country ID using the following resource:
GET https://api.kinow.com/api/countries (opens new window)

$countriesApi = new Kinow\Client\Api\CountriesApi();

try {
    $result = $countriesApi->getCountries();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CountriesApi->getCountries: ', $e->getMessage(), PHP_EOL;
}

countriesApi = new KinowSDK.CountriesApi()

countriesApi.getCountries().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

countries_api = kinow_client.CountriesApi()

try:
    api_response = countries_api.get_countries()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CountriesApi->get_countries: %s\n" % e)

Once we have retrieved countries list, we can pick the correct ID following user address invoicing.

Create user account

Now we can create a new Customer account by using following resource:
POST https://api.kinow.com/api/customers (opens new window)

$customersApi = new Kinow\Client\Api\CustomersApi();
$body = new \Kinow\Client\Model\Customer();
$body
    ->setEmail('user@your-company.com')
    ->setFirstname('Firstname')
    ->setLastname('Lastname')
    ->setPassword('password')
    ->setIdCountry(8);
try {
    $result = $customersApi->createCustomer($body);
    print_r($result);
} catch (\Kinow\Client\ApiException $e) {
    echo 'Exception when calling CustomersApi->createCustomer: ', $e->getMessage(), PHP_EOL;
}

customersApi = new KinowSDK.CustomersApi()

body = {
  firstname: 'firstname',
  lastname: 'lastname',
  email: 'user@your-company.com',
  password: 'password',
  id_country: 8
}

customersApi.createCustomer(body).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

customers_api = kinow_client.CustomersApi()

body = kinow_client.Customer()
body.email = 'user@your-company.com'
body.firstname = 'Firstname'
body.lastname = 'Lastname'
body.password = 'password'
body.id_country = 8

try:
    api_response = customers_api.create_customer(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CustomersApi->create_customer: %s\n" % e)

User login

You can check Customer credentials using the following resource:
POST https://api.kinow.com/api/customers/validate-credentials (opens new window)

Theses parameters are mandatory:

Name	Details
email	String - User email to validate
password	String - User password to check

API will return you a CredentialsValidation object, which contains following properties:

Name	Details
valid	Boolean - Status of credentials validation
customer_id	Integer - Customer ID linked to email address

$customersApi = new Kinow\Client\Api\CustomersApi();

try {
    $result = $customersApi->validateCustomerCredentials('user@your-company.com', 'password');
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CustomersApi->validateCustomerCredentials: ', $e->getMessage(), PHP_EOL;
}

customersApi = new KinowSDK.CustomersApi()

customersApi.validateCustomerCredentials('user@your-company.com', 'password').then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

customers_api = kinow_client.CustomersApi(api_client)

try:
    api_response = customers_api.validate_customer_credentials('user@your-company.com', 'password')
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CustomersApi->validate_customer_credentials: %s\n" % e)

Retreive products

You can retrieve Product list using following resource:
GET https://api.kinow.com/api/products (opens new window)

Note you can use pagination properties.

API will return you an array of Product objects with various properties, such as:

Name	Details
id	Integer - Product ID
active	Integer - Determines if Product is enabled
name	Array[I18Field] - Product names for each languages
date_add	String - Date of creation

And many more...

$productsApi = new Kinow\Client\Api\ProductsApi();

try {
    $result = $productsApi->getProducts();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductsApi->getProducts: ', $e->getMessage(), PHP_EOL;
}

productsApi = new KinowSDK.ProductsApi()

productsApi.getProducts().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

products_api = kinow_client.ProductsApi()

try:
    api_response = products_api.get_products()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductsApi->get_products: %s\n" % e)

Cart management

To create a Cart object, several fields are mandatory:

Name	Details
id_customer	Integer - Customer account to attach to this Cart
id_currency	Integer - Curency object to use in Cart
id_lang	Integer - Language object to use in Cart

Retrieve currencies

First of all, we have to retrieve the Currency ID using the following resource:
GET https://api.kinow.com/api/currencies (opens new window)

$currenciesApi = new Kinow\Client\Api\CurrenciesApi();

try {
    $result = $currenciesApi->getCurrencies();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CurrenciesApi->getCurrencies: ', $e->getMessage(), PHP_EOL;
}

currenciesApi = new KinowSDK.CurrenciesApi()

currenciesApi.getCountries().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

currencies_api = kinow_client.CurrenciesApi()

try:
    api_response = currencies_api.get_currencies()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CurrenciesApi->get_currencies: %s\n" % e)

Once we have retrieved currencies list, we can pick the correct ID following user settings.

Retrieve languages

Then, we have to retrieve the Language ID using the following resource:
GET https://api.kinow.com/api/languages (opens new window)

$languagesApi = new Kinow\Client\Api\LanguagesApi();

try {
    $result = $languagesApi->getLanguages();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LanguagesApi->getLanguages: ', $e->getMessage(), PHP_EOL;
}

languagesApi = new KinowSDK.LanguagesApi()

languagesApi.getLanguages().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

languages_api = kinow_client.LanguagesApi()

try:
    api_response = languages_api.get_languages()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LanguagesApi->get_languages: %s\n" % e)

Now we can select the appropriate ID following user preferences.

Create a new cart

Now we can create a new Cart object by using following resource:
POST https://api.kinow.com/api/carts (opens new window)

$body = new \Kinow\Client\Model\Cart();
$body
    ->setIdCustomer(42)
    ->setIdCurrency(1)
    ->setIdLang(1);
try {
    $result = $cartsApi->createCart($body);
    print_r($result);
} catch (\Kinow\Client\ApiException $e) {
    echo 'Exception when calling CartsApi->createCart: ', $e->getMessage(), PHP_EOL;
}

cartsApi = new KinowSDK.CartsApi()

body = {
  id_currency: 1,
  id_lang: 1,
  id_customer: 42
}

cartsApi.createCart(body).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

carts_api = kinow_client.CartsApi()

body = kinow_client.Cart()
body.id_currency = 1
body.id_lang = 1
body.id_customer = 42

try:
    api_response = carts_api.create_cart(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartsApi->create_cart: %s\n" % e)

Add some products

Finaly we can add some products to our cart using this resource:
POST https://api.kinow.com/api/carts/{cart_id}/products (opens new window)

$cartsApi = new Kinow\Client\Api\CartsApi();
try {
    $result = $cartsApi->addProductToCart(21, 5, 3);
    print_r($result);
} catch (\Kinow\Client\ApiException $e) {
    echo 'Exception when calling CartsApi->addProductToCart: ', $e->getMessage(), PHP_EOL;
}

cartsApi = new KinowSDK.CartsApi()

cartsApi.addProductToCart(21, 5, 3).then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

carts_api = kinow_client.CartsApi()

try:
    api_response = carts_api.add_product_to_cart(21, 5, 3)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartsApi->create_cart: %s\n" % e)

Payment process

Our user has filled his cart and would like to order his products. We have to display a list of payment gateways and let him choose the right one.

Retrieve payment gateways

Use following resource to retrieve a list of PaymentGateway:
GET https://api.kinow.com/api/payment-modules (opens new window)

$paymentModulesApi = new Kinow\Client\Api\PaymentModulesApi();

try {
    $result = $paymentModulesApi->getPaymentModules();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PaymentModulesApi->getPaymentModules: ', $e->getMessage(), PHP_EOL;
}

paymentModulesApi = new KinowSDK.PaymentModulesApi()

paymentModulesApi.getPaymentModules().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

payment_modules_api = kinow_client.PaymentModulesApi()

try:
    api_response = payment_modules_api.get_payment_modules()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentModulesApi->get_payment_modules: %s\n" % e)

Load payment gateway URL

Use this resource to get the payment URL:
GET https://api.kinow.com/api/carts/{cart_id}/payments/{payment_name} (opens new window)

$cartsApi = new Kinow\Client\Api\CartsApi();

try {
    $result = $cartsApi->getPaymentUrl();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CartsApi->getPaymentUrl: ', $e->getMessage(), PHP_EOL;
}

cartsApi = new KinowSDK.CartsApi()

cartsApi.getPaymentUrl().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

carts_api = kinow_client.CartsApi()

try:
    api_response = carts_api.get_payment_url()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartsApi->get_payment_url: %s\n" % e)

Once user has choose his payment gateway, you can redirect him to the payment URL page (external).

Video player

Check user access to product

When a user reach a product page (eg. a movie page), we'd like to display him a button to watch the video content linked to the product.

First of all, we have to check if user as access to this product, this means he has bought the product (TVOD) or subscribed to an offer (SVOD) granting him access to the product.

You can check user access to product using this resource:
GET https://api.kinow.com/api/customers/{customer_id}/products/{product_id}/has-access (opens new window)

$customersApi = new Kinow\Client\Api\CustomersApi();

try {
    $result = $customersApi->getCustomerHasAccessToProduct();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CustomersApi->getCustomerHasAccessToProduct: ', $e->getMessage(), PHP_EOL;
}

customersApi = new KinowSDK.CustomersApi()

customersApi.getCustomerHasAccessToProduct().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

customers_api = kinow_client.CustomersApi()

try:
    api_response = customers_api.get_customer_has_access_to_product()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CustomersApi->get_customer_has_access_to_product: %s\n" % e)

Retrieve videos

Once we know that user has access to the current product, we can display him the list of videos inside this product, in order to let him pick the right one to watch.

Use this resource to retrieve the videos list inside a product:
GET https://api.kinow.com/api/products/{product_id}/videos (opens new window)

$productsApi = new Kinow\Client\Api\ProductsApi();

try {
    $result = $productsApi->getVideosFromProduct();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductsApi->getVideosFromProduct: ', $e->getMessage(), PHP_EOL;
}

productsApi = new KinowSDK.ProductsApi()

productsApi.getVideosFromProduct().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

products_api = kinow_client.ProductsApi()

try:
    api_response = products_api.get_videos_from_product()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductsApi->get_videos_from_product: %s\n" % e)

Check user access to video

As TVOD and SVOD accesses can have specific restrictions, we have to check if user also has access to the selected video.

You can check user access to video using this resource:
GET https://api.kinow.com/api/customers/{customer_id}/videos/{video_id}/has-access (opens new window)

$customersApi = new Kinow\Client\Api\CustomersApi();

try {
    $result = $customersApi->getCustomerHasAccessToVideo();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CustomersApi->getCustomerHasAccessToVideo: ', $e->getMessage(), PHP_EOL;
}

customersApi = new KinowSDK.CustomersApi()

customersApi.getCustomerHasAccessToVideo().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

customers_api = kinow_client.CustomersApi()

try:
    api_response = customers_api.get_customer_has_access_to_video()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CustomersApi->get_customer_has_access_to_video: %s\n" % e)

Retrieve video player URL

Use this resource to get the player URL:
GET https://api.kinow.com/api/videos/{video_id}/player (opens new window)

$videosApi = new Kinow\Client\Api\VideosApi();

try {
    $result = $videosApi->getVideoPlayer();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling VideosApi->getVideoPlayer: ', $e->getMessage(), PHP_EOL;
}

videosApi = new KinowSDK.VideosApi()

videosApi.getVideoPlayer().then(function(data) {
  console.log('API called successfully. Returned data: ' + data);
}, function(error) {
  console.error(error);
});

videos_api = kinow_client.VideosApi()

try:
    api_response = videos_api.get_video_player()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VideosApi->get_video_player: %s\n" % e)

This URL has to be loaded inside an iframe:

<iframe src="http://url-to-player-page.com" frameborder="0"
  allowfullscreen="true" mozallowfullscreen="true" webkitallowfullscreen="true">
</iframe>