The onSessionStarted event is fired after the current session context is loaded and initialized.  This event will also pass a SessionContext object into any registered callbacks.

(function contextOverride(sdk){
sdk.events.registerHandler(sdk.events.onSessionStarted, function(ctx){
       // peek into the sessionId 
       var sessionid = ctx.user.sessionId;
       // override the contentId
       ctx.contentId = getCustomContentId();
});
 })(window.syncPaymeterSdk)

This event is the last chance to modify any of the session context before the authorization call.  The Session context is fully loaded at this point so you can examine current values and override if necessary.

The onSessionSaving event is fired after the authorization call has completed and signals the point at which the PaymeterSdk is beginning the process of saving session data to the local cookie.  You can intercept this event to change any of the session values before they are saved.

The Paymeter Sdk will pass the current Session Context into any registered callback functions for this event.

The onSessionSaved event is fired once the session context has been saved. There are not arguments passed to the callback functions registered to handle this event. 

The Session Starting, Session Started, and Session Saving events will pass a Session Context object into any registered callback functions. The Session Context Object maintains the data that is required for authorizing a user.  Some of this data is persisted from one user session to the next (like SessionId, userId, etc.) and other data is specific to the current page (like currentPage, referringPage, and contentId).

Session data that must persist from page to the next is stored in a local cookie named: syncmeter-user-ctx.

// sessionContext
{
       'user':{
                     'sessionId':string,
                     'userId':int,
                     'authToken':string,
                     'externalId':string
              },
       'currentPage':string,
       'referringPage':string,
       'contentId':string,
       'channel':string,
       'pageHistory':object,
       'clientInfo':string
}

Session context is loaded at the beginning of the authorization process and then saved upon completion of the authorization process.

The onAuthorizeStarting event is triggered immediately before the server authorization API is called.  There is no data passed into any registered callbacks for this event so there is no opportunity at this point to change the impending server call.  You can bind functions to this event to track workflow (analytics data, logging, etc.).

The onAuthorizeSuccess event is triggered if the current user has been authorized to view the current content.  The Paymeter SDK will pass an Authorization Context Object into any registered callback functions (see below).

Example:

(function authorizeSuccessOverride(sdk){
       sdk.events.registerHandler(sdk.events.onAuthorizeSuccess,function(ctx){
              console.log('paymeter says user is authorized. ' + ctx.statusMsg);
       });
})(window.syncPaymeterSdk);

The onAuthorizeFailed event is triggered whenever the server responds that the given user is not allowed to view the given content.  This usually occurs when a user has exhausted her free views of the content but can also happen if a known, authenticated user does not have appropriate plans to grant access.  The SDK will pass a Authorization Context Object into any registered callback functions (see below).

Example:

(function authorizationFailOverride(sdk){
       sdk.events.registerHandler(sdk.events.onAuthorizeFailed, function(ctx){
              console.log('User not authorized. ' + ctx.statusMsg);
       });
})(window.syncPaymeterSdk);

Note: the onAuthorizationFailed event will usually be preceded by the onWallFired event.

An authorization failure usually results in a meter Paywall (the default implementation of the PaymeterSdk automatically loads and renders a pre-defined paywall HTML overlay).  The onWallFired event is triggered if the server responds indicating that the user is not authorized to view content.  This event will fire immediately before the onAuthorizeFailed event.  Like the other authorization events, this one will pass an Authorization Context Object into any registered callback functions.

Example:

(function paywallOverride(sdk){
       sdk.events.registerHandler(sdk.events.onWallFired, function(ctx){
              console.log('Time to show a paywall!. ' + ctx.statusMsg);
              myEventTracker.trackWallHit(ctx.newSessionId);
       });
})(window.syncPaymeterSdk);

The onWarningFired event is triggered when a user has hit a specific number of views that have been configured as a "warning threshold".  Administrators can define specific view counts for which a warning (aka 'alert') might be displayed to the user giving them some information about remaining free views, special offers, etc.

A user is still considered to be 'authorized' when the onWarningEvent is fired; however, the onAuthorizeSuccess event is not actually triggered if a user has reach a warning threshold.   An Authorization Context Object is passed to any registered callback functions.

Example:

(function warningOverride(sdk){
       sdk.events.registerHandler(sdk.events.onWarningFired, function(ctx){
              var cnt = ctx.viewCount;
              var total = ctx.viewCount + ctx.remainingViewCount;
              var msg = 'User has read ' + cnt.toString() +
                         ' out of ' + total.toString();
              console.log('Warning to user!.' + msg  );
});
})(window.syncPaymeterSdk);

The onServerError event is triggered if there is an unexpected error reported from the server. This is rare but when it does occur, the client must decide the best way to handle it.  The default Paymeter implementation will silently ignore server errors in order to prevent readers from being blocked from reading content when environmental circumstances prevent the Paymeter API from operating as expected.  The same Authorization Context Object is included in any registered callbacks and can be queried to get specific error details.

Example:

//     Report API timeout errors
(function reportTimeoutErrors(sdk){
       sdk.events.registerHandler(sdk.events.onServerError,function(ctx){
              myCustomBugTracker.RecordBug('Paymeter server error: ' +
                     ctx.statusCode + ':' + ctx.statusMsg);
});

})(window.syncPaymeterSdk);

The authorization context object is sent to callback functions that are bound to the onAuthorizeSuccess, onWarningFired, onWallFired, and onAuthorizeFailed events.  The object provides contextual information about the authorization call to the server.

//     Authorization Context Object
//
{
'newSessionId':string,
'statusCode':string,
'statusMsg':string,
'remainingViewCount':int,
'viewCount':int,
'authorized':bool,
'registerUrl':string,
'error':bool
}