Permission Service

The default PermissionService implementation is the OpenPermissionService, which is essentially a stub that tells you everything is allowed, while the UserService has no default implementation set.

<aliases xmlns="http://schema.caplin.com/CaplinTrader/aliases">
    <!-- you can add any overrides you need here -->

    <alias name="br.user-prompt-service" \
      class="caplin.webcentric.alert.WebcentricAlertDispatcher"/>
    <alias name="caplin.preference-service" \
      class="caplin.webcentric.providers.WebcentricPreferencesService"/>
    <alias name="caplin.frame-manager-service" \
      class="caplin.webcentric.frame.WebcentricFrameManager"/>
    <alias name="caplin.message-service" \
      class="caplin.sljsadapter.providers.StreamLinkMessageService"/>

    <alias name="caplin.permission-service" \
      class="caplin.sljsadapter.providers.StreamLinkPermissionService"/>(1)
    <alias name="caplin.user-service" \
      class="caplin.sljsadapter.providers.StreamLinkUserService"/>(2)
</aliases>

The StreamLinkPermissionService, being a Delayed Readiness service, can only be used by the tile after the connection to the server has been established, the Permissions container has been requested, and the permissions have been received in response. Therefore it is necessary to be notified when the service’s initialisation is complete.

App.prototype._initialiseDelayedReadinessServices = function() {
    var successCallback = this._onServicesInitialisedSuccess.bind(this);
    var failureCallback = this._onServicesInitialisedError;

    ServiceRegistry.initializeServices(successCallback, failureCallback);
};

The last thing we will do is defer the creation of our three tiles until after the services have initialised. Remove the three this.createTile() calls from the constructor of the class. Paste them into your service initialisation success callback instead:

App.prototype._onServicesInitialisedSuccess = function() {
    this.createTile('GBPUSD');
    this.createTile('GBPCHF');
    this.createTile('GBPAUD');
};

When the tile is created it can start to listen for permission updates from the Permission Service. Firstly we will query whether a user has permission to view prices for a particular currency pair. This translates to: "Does demouser have permission to VIEW (action) /FX/<currencypair> (product)?" The second parameter is the namespace, which we are not using - this should be passed as null.

function TilePresentationModel(currencyPair) {
   ...

   var product = '/FX/' + this.currencyPair.getValue();
   ServiceRegistry.getService('caplin.permission-service').addPermissionListener(product, null, 'VIEW', this);
};

You will notice that the last parameter for addPermissionListener() is the listener for permission updates. As usual we are passing this, so we must once again declare that our class implements the relevant listener. The relevant listener this time is caplin.services.security.PermissionServiceListener, so let’s add that to our block of implemented interfaces just under the constructor:

var PermissionServiceListener = require('caplin/services/security/PermissionServiceListener');
...

topiarist.extend(TilePresentationModel, PresentationModel);
topiarist.inherit(TilePresentationModel, SubscriptionListener);
topiarist.inherit(TilePresentationModel, ConnectionServiceListener);
topiarist.inherit(TilePresentationModel, StateChangedListener);
topiarist.inherit(TilePresentationModel, PermissionServiceListener);

It would be good if our tile only tries to subscribe to streaming prices if it has the permission to view them. Let’s delete these two lines from our Tile constructor:

var messageService = ServiceRegistry.getService('caplin.message-service');
this._subscription = messageService.subscribe('/FX/' + this.currencyPair.getValue(), this);

Now we must implement one of the methods from that PermissionServiceListener interface. Incidentally, it’s worth noting that the PermissionServiceListener interface is a forgiving one - unlike some of the other interfaces it does not throw errors if you don’t implement all of the methods. In this sense it is not a "true" interface, but it allows you the flexibility of only implementing the methods you care about. We are able to do this because interfaces are not a concept that is supported natively in JavaScript, we have our own mechanism to simulate them.

TilePresentationModel.prototype.onSinglePermissionChanged = function(isAuthorized) {
    if (isAuthorized) {
        var messageService = ServiceRegistry.getService('caplin.message-service');

        this._subscription = messageService.subscribe('/FX/' + this.currencyPair.getValue(), this);
        this.message.setValue('');
    } else {
        this.message.setValue(i18n('mycompany.tutorial.tile.no_view_message') + this.currencyPair.getValue());
    }
};

Refresh the application. Everything almost works, except that you have an untranslated internationalisation message in the GBPAUD tile. The other two tiles are working as normal. As a final exercise, try fixing this yourself so that the tile says "You do not have the necessary permission to see rates for GBPAUD". You will need to add a new i18n token to the language files in the resources directory of the tile blade.

As a further task, try updating your onSinglePermissionChanged()callback method so that it disables the buy and sell buttons if the user does not have the permission, and enables them if the user does have the permission. You will need to add lines like this to the relevant places in the if/else block:

this.buyRate.enabled.setValue(false);

You can query individual or group permissions using the methods on the Permission Service such as canUserPerformAction().

TilePresentationModel.prototype._executeTrade = function(buySell) {
    var product = '/FX/' + this.currencyPair.getValue();
    var canTrade = ServiceRegistry.getService('caplin.permission-service').canUserPerformAction(product, null, 'FX-ESP-TRADE');

    if (canTrade) {
        // ... existing logic goes here
    } else {
        this.message.setValue(i18n('mycompany.tutorial.tile.no_esp_message') + this.currencyPair.getValue());
    }
};

Note that we are using another new i18n token, mycompany.tutorial.tile.no_esp_message. This does not exist, so you’ll have to add it to your language file(s) as you did in the example above.