Implémentation des licences

Cette section de documentation vous guide tout au long du processus d’intégration de la bibliothèque de licences SDK dans votre package d’activités.

Veuillez suivre les étapes suivantes selon que votre package a été développé avec ou sans UiPath Activity Creator :

• a été développé à l’aide de UiPath Activity Creator

• le package n’a pas été développé à l’aide de UiPath Activity Creator

Attention : votre solution VS doit être compatible avec .Net 4.6.1.

Remarque :

La mise en œuvre des licences pour les activités personnalisées compatibles avec .NET 6 ou Windows repose sur le fournisseur. Marketplace ne fournit pas de bibliothèque de licences compatible avec .NET6. Il fournit une bibliothèque de licences compatible avec Windows-Legacy.

Dans le cas où votre package a été développé à l’aide de UiPath Activity Creator

1. Dans la méthode ExécuterAsync ( ExecuteAsync ) de chacune de vos activités, ajoutez le contrôle de validation, sauf si vous avez un scénario d'activité Étendue.

   Si vous disposez d'un scénario Activité Étendue (Scope Activity), vous pouvez ajouter le contrôle de validation à cette activité uniquement si toutes vos activités sont soumises à licence.

   protected override async Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
           {
               // Inputs
               var firstNumber = FirstNumber.Get(context);
               var secondNumber = SecondNumber.Get(context);
               // License validation
               #if !DEBUG
                   //if your package is MyCompany.MyPackageName.Activities.1.0.0.nupkg
                   await Validator.ValidateAsync(context, "MyCompany.MyPackageName.Activities");
               #endif
               ///////////////////////////
               // Add execution logic HERE
               ///////////////////////////
               // Outputs
               return (ctx) => {
               };
           }

   Remarque :

   • L'objet de contexte ne peut être transmis qu'une seule fois et utilisé uniquement dans la méthode dans laquelle il a été transmis. Par exemple, après l'appel Validator.ValidateAsync , elle ne peut plus être utilisée dans la méthode ExecuteAsync .
   • Compte tenu de l'exigence ci-dessus, cela signifie également que les variables d'entrée doivent être lues avant de transmettre le contexte à la méthode/bibliothèque de licence.

2. Référencez la bibliothèque Licensing.dll dans votre projet .Activities et ajoutez l’instruction using :

   
   

   

   
   

   using UiPath.Marketplace.License.Validations;

3. La configuration est terminée - créez votre package et assurez-vous que la bibliothèque Licensing.dll est présente dans le contenu du package (dans le dossier lib ). Vous pouvez ensuite le soumettre sur Marketplace.

Si votre package n’a pas été développé à l’aide de UiPath Activity Creator

Si votre activité initiale ressemble à ceci :

using System;
using System.Activities;
using System.ComponentModel;
    namespace ClassMathCustomActivity
{
    public class SimpleFormula : CodeActivity
    {
        [Category("Input")]
        [RequiredArgument]
        public InArgument<double> FirstNumber { get; set; }
        [Category("Input")]
        public InArgument<double> SecondNumber { get; set; }
        [Category("Output")]
        public OutArgument<double> ResultNumber { get; set; }
        protected override void Execute(CodeActivityContext context)
        {
            var firstNumber = FirstNumber.Get(context);
            var secondNumber = SecondNumber.Get(context);
            var result = System.Math.Pow(firstNumber + secondNumber, 2);
            ResultNumber.Set(context, result);
        }
    }
}

La modification la plus importante que vous devez apporter concerne la méthode execute , qui doit être une ExecuteAsync.

La solution proposée consiste à créer une classe AsyncTaskCodeActivity.cs qui devrait ressembler à ceci :

using System;
using System.Activities;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
namespace ClassMathCustomActivity
{
  internal struct AsyncTaskCodeActivityImplementation : IDisposable
  {
    private CancellationTokenSource _cancellationTokenSource;
    private bool _tokenDisposed;
    public void Cancel()
    {
      if (!_tokenDisposed)
      {
        _cancellationTokenSource?.Cancel();
        _cancellationTokenSource?.Dispose();
        _tokenDisposed = true;
      }
    }
    public IAsyncResult BeginExecute(AsyncCodeActivityContext context
      , Func<AsyncCodeActivityContext, CancellationToken, Task<Action<AsyncCodeActivityContext>>> onExecute
      , AsyncCallback callback, object state)
    {
      if (!_tokenDisposed)
      {
        _cancellationTokenSource?.Dispose();
      }
      _cancellationTokenSource = new CancellationTokenSource();
      _tokenDisposed = false;
      TaskCompletionSource<Action<AsyncCodeActivityContext>> taskCompletionSource = new TaskCompletionSource<Action<AsyncCodeActivityContext>>(state);
      Task<Action<AsyncCodeActivityContext>> task = onExecute(context, _cancellationTokenSource.Token);
      var cancellationTokenSource = _cancellationTokenSource;
      task.ContinueWith(t =>
      {
        if (t.IsFaulted)
        {
          taskCompletionSource.TrySetException(t.Exception.InnerException);
        }
        else if (t.IsCanceled || cancellationTokenSource.IsCancellationRequested)
        {
          taskCompletionSource.TrySetCanceled();
        }
        else
        {
          taskCompletionSource.TrySetResult(t.Result);
        }
        callback?.Invoke(taskCompletionSource.Task);
      });
      return taskCompletionSource.Task;
    }
    public void EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
    {
      Task<Action<AsyncCodeActivityContext>> task = (Task<Action<AsyncCodeActivityContext>>)result;
      if (task.IsFaulted)
      {
        ExceptionDispatchInfo.Capture(task.Exception.InnerException).Throw();
      }
      if (task.IsCanceled)
      {
        context.MarkCanceled();
      }
      task.Result?.Invoke(context);
      if (!_tokenDisposed)
      {
        _cancellationTokenSource?.Dispose();
        _tokenDisposed = true;
      }
    }
    private bool _disposed; // To detect redundant calls
    public void Dispose()
    {
      if (!_disposed)
      {
        if (!_tokenDisposed)
        {
          if (_cancellationTokenSource != null)
            _cancellationTokenSource.Dispose();
          _tokenDisposed = true;
        }
        _disposed = true;
      }
    }
  }
  public abstract class AsyncTaskCodeActivity : AsyncCodeActivity, IDisposable
  {
    private AsyncTaskCodeActivityImplementation _impl = new AsyncTaskCodeActivityImplementation();
    protected override void Cancel(AsyncCodeActivityContext context)
    {
      _impl.Cancel();
      base.Cancel(context);
    }
    protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
    {
      return _impl.BeginExecute(context, ExecuteAsync, callback, state);
    }
    protected override void EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
    {
      _impl.EndExecute(context, result);
    }
    protected abstract Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken);
    #region IDisposable Support
    private bool _disposed = false; // To detect redundant calls
    protected virtual void Dispose(bool disposing)
    {
      if (!_disposed)
      {
        if (disposing)
        {
        }
        _impl.Dispose(); //structs are not garbage collected so they fit in the unmanaged bucket
        _disposed = true;
      }
    }
    public void Dispose()
    {
      // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
      Dispose(true);
      GC.SuppressFinalize(this);
    }
    #endregion
  }
  public abstract class AsyncTaskCodeActivity<T> : AsyncCodeActivity<T>, IDisposable
  {
    private AsyncTaskCodeActivityImplementation _impl = new AsyncTaskCodeActivityImplementation();
    protected override void Cancel(AsyncCodeActivityContext context)
    {
      _impl.Cancel();
      base.Cancel(context);
    }
    protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
    {
      return _impl.BeginExecute(context, ExecuteAsync, callback, state);
    }
    protected override T EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
    {
      _impl.EndExecute(context, result);
      return Result.Get(context);
    }
    protected abstract Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken);
    #region IDisposable Support
    private bool _disposed = false; // To detect redundant calls
    protected virtual void Dispose(bool disposing)
    {
      if (!_disposed)
      {
        if (disposing)
        {
        }
        _impl.Dispose(); //structs are not garbage collected so they fit in the unmanaged bucket
        _disposed = true;
      }
    }
    public void Dispose()
    {
      // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
      Dispose(true);
      GC.SuppressFinalize(this);
    }
    #endregion
  }
}

L'activité modifiée devrait ressembler à ceci :

using System;
using System.Threading.Tasks;
using UiPath.Marketplace.License.Validations;
using System.ComponentModel;
using System.Activities;
using System.Threading;
namespace ClassMathCustomActivity
{
  public class SimpleFormula : AsyncTaskCodeActivity
  {
    [Category("Input")]
    [RequiredArgument]
    public InArgument<double> FirstNumber { get; set; }
    [Category("Input")]
    public InArgument<double> SecondNumber { get; set; }
    [Category("Output")]
    public OutArgument<double> ResultNumber { get; set; }
    protected override async Task<Action<AsyncCodeActivityContext>> ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
    {
      var firstNumber = FirstNumber.Get(context);
      var secondNumber = SecondNumber.Get(context);
      // check for license after reading input arguments
      #if !DEBUG
                //if your package is MyCompany.MyPackageName.Activities.1.0.0.nupkg
                await Validator.ValidateAsync(context, "MyCompany.MyPackageName.Activities");
      #endif
      return (ctx) =>
      {
        var result = System.Math.Pow(firstNumber + secondNumber, 2);
        ResultNumber.Set(ctx, result);
      };
    }
  }
}

Remarque :

Il est important que la ligne 24 soit exécutée juste après la lecture de tous les arguments d'entrée. Dans l'exemple ci-dessus, les lignes 20 et 21 sont utilisées pour lire les arguments d'entrée et les lignes 26 à 30 sont utilisées pour définir l'argument de sortie.

Une dernière chose : lors de la création de votre fichier .nupkg, , assurez-vous que la bibliothèque Licensing.dll est présente dans le contenu du package (dans le dossier lib ).

FAQ

Que se passe-t-il une fois ces modifications mises en œuvre ?

Après avoir implémenté les modifications et créé le fichier .nupkg, vous devez le soumettre à Marketplace pour publication.

Puis-je obtenir le fichier de licence à des fins de test ?

Non, afin de tester les activités, vous pouvez utiliser la directive de préprocesseur C# pour le débogage (#if !DEBUG)

Comment les clients pourront-ils obtenir le fichier de licence ?

Après qu’un utilisateur a effectué un achat, une licence .lic sera généré et mis à leur disposition sur Marketplace. Ils pourront télécharger le fichier, puis suivre les étapes nécessaires à l'utilisation des activités.