Licence et quotas

Vérifier que vos identifiants sont acceptés, et lire les informations de votre licence : messages restants, taille maximale des fichiers, permissions.

Prérequis

Vos identifiants : voir Identifiants et environnements.

Vérifier la licence

IsLicenceIsValid vérifie le serial, l'utilisateur et le mot de passe de l'API, ainsi que l'adresse courriel du titulaire de la licence.

var args = new IsLicenceIsValidArgs(endpoint, serial, apiUser, apiPassword, courrielTitulaire);
bool valide = LicenceHelper.IsLicenceIsValid(args);

from secure_exchanges_sdk import LicenceHelper

valide = LicenceHelper.is_licence_valid(
    api_client=client,
    serial=serial, api_user=api_user, api_password=api_password,
    email=courriel_titulaire,
)

use SecureExchanges\SDK\Helpers\LicenceHelper;

$valide = LicenceHelper::isLicenceValid(
    apiClient: $client,
    serial: $serial, apiUser: $apiUser, apiPassword: $apiPassword,
    email: $courrielTitulaire,
);

Un résultat false ne prouve pas que la licence est invalide : il arrive aussi quand l'adresse est mal formée ou que le serveur n'a pas pu être joint. Utilisez cette vérification au démarrage de votre application, et journalisez le résultat sans les identifiants.

Lire les informations de la licence

GetSerialInfoResponse info = LicenceHelper.GetSerialInfo(
    new GetSerialInfoArgs(endpoint, serial, apiUser, apiPassword));

if (info != null && info.PlanPermission != null)
{
    int messages = info.NbTotalMessage;
    long tailleMax = info.LicenceAutorisation.MaxFileSize;   // en octets
}

info = LicenceHelper.get_serial_info(
    api_client=client,
    serial=serial, api_user=api_user, api_password=api_password,
)

if info is not None:
    messages = info.nb_total_message
    taille_max = info.licence_autorisation.max_file_size if info.licence_autorisation else None  # en octets

$info = LicenceHelper::getSerialInfo(
    apiClient: $client,
    serial: $serial, apiUser: $apiUser, apiPassword: $apiPassword,
);

if ($info !== null) {
    $messages = $info->nbTotalMessage;
    $tailleMax = $info->licenceAuthorisation?->maxFileSize;   // en octets
}

En .NET, GetSerialInfo ne vérifie pas le statut du serveur : en cas d'erreur, il retourne une réponse dont les valeurs sont à zéro, et dont PlanPermission et LicenceAutorisation sont null. Il retourne null si l'échange de clés échoue, et lève une exception si l'un des identifiants est vide. Testez la réponse et PlanPermission, comme dans l'exemple.

GetSerialInfo retourne null (None) en cas d'erreur.

Informations retournées

Champ	Contenu
`NbTotalMessage`	Nombre de messages qu'il vous reste à envoyer.
`MaxFileSize` (dans `LicenceAutorisation`)	Taille totale maximale des fichiers d'un message, en octets.
`MaxMinMsgRetention` (dans `LicenceAutorisation`)	Durée de conservation maximale d'un message, en minutes.
`Permission`	Fonctions permises par le forfait, sous forme de combinaison de drapeaux.
`PlanPermission`	Détail du forfait, dont son identifiant `PlanID`.
`PurchaseDate`	Date de création du serial, dans le fuseau horaire de votre compte.
`ContextualKeys`	Clés contextuelles de votre organisation : voir Format des paramètres de rappel.

NbBusinessMessage et NbUserMessage viennent d'un ancien quota de messages propre à l'organisation, qui n'est plus attribué : ne les utilisez pas.

La réponse ne contient ni l'adresse du titulaire de la licence, ni la date d'échéance de l'abonnement : aucun SDK ne les expose. Pour vérifier une adresse, utilisez IsLicenceIsValid.

Pour adapter votre application, lisez les limites (taille, conservation, permissions) plutôt que le nom du forfait : elles suivent les changements de forfait.

Attention

N'utilisez pas l'énumération SerialTypePermission des SDK Python et PHP pour décoder permission : ses valeurs ne correspondent pas à celles du serveur.

Forfaits

PlanPermission.PlanID est l'identifiant du forfait, sous forme de chaîne. Comparez-le aux constantes des SDK plutôt qu'à une valeur écrite à la main :

SDK	Accès
.NET	`LicenceHelper.PLANID_APIDEBASE`, etc.
Python	`PLANID_APIDEBASE`, etc., dans `secure_exchanges_sdk.helpers.licence_helper`
PHP	`PlanId::APIDEBASE`, etc.

Constante	Valeur de `PlanID`
`DEBASE`	`DEBASE`
`APIDEBASE`	`APIDEBASE`
`COMPLET`	`COMPLET`
`APICOMPLET`	`APICOMPLET`
`COMPLET2100`	`COMPLET2100`
`APICOMPLET2100`	`APICOMPLET2100`
`DEBASE_PARTAGER`	`DEBASE-P`
`COMPLET_PARTAGER`	`COMPLET-P`
`COMPLET2100_PARTAGER`	`COMPLET2100-P`
`SESAR`	`SESAR`
`COMPLET5000`	`COMPLET5000`
`COMPLET7500`	`COMPLET7500`
`COMPLET10000`	`COMPLET10000`
`COMPLET15000`	`COMPLET15000`
`COMPLET20000`	`COMPLET20000`
`COMPLET25000`	`COMPLET25000`
`NOTSET`	`NotSet`

En .NET, lisez PlanID et non PlanPermission.Plan : les valeurs de l'énumération Plan ne correspondent pas à celles du serveur.

Identifiant du poste (DeviceID)

Le SDK joint à chaque demande de jeton un identifiant du poste : le domaine et le compte qui exécutent votre application (domaine\utilisateur).

SDK	Lire l'identifiant
.NET	`LicenceHelper.DeviceID`
Python	`LicenceHelper.get_device_id()`
PHP	`LicenceHelper::getDeviceId()`

Identifiants obtenus dans le portail, le cas habituel : l'identifiant du poste n'a aucun effet.
Identifiants activés depuis un poste (CreateLicence, en .NET) : ils sont liés à cet identifiant. Changer de compte de service ou de domaine les rend inutilisables.
Renseignement personnel : l'identifiant contient le nom du compte qui exécute votre application. Ne le journalisez pas sans raison.

Erreurs fréquentes

Symptôme	Cause probable	Solution
.NET : exception « Invalid user, api or password. Someone is empty »	Un identifiant vaut `Guid.Empty` : le secret n'a pas été chargé	Vérifiez la lecture de vos secrets.
.NET : toutes les valeurs à zéro	Erreur du serveur : identifiants refusés ou environnement erroné	Vérifiez que les identifiants correspondent à l'environnement (préproduction ou production).
`IsLicenceIsValid` retourne false	Adresse du titulaire erronée ou mal formée, environnement erroné, réseau	Vérifiez l'adresse et l'environnement.
.NET : `IsLicenceIsValid(endpoint, serial, ...)` ne compile pas	Signature d'un ancien guide	Passez un `IsLicenceIsValidArgs`, comme dans l'exemple.

Et ensuite

Identifiants et environnements
Pièces jointes : limites de taille

Table of Contents