CTIOperationResponse : champ d’application, global

  • Rversion finale: Yokohama
  • Mis à jour 30 janv. 2025
  • 22 minutes de lecture

    • L’include de script CTIOperationResponse fournit des méthodes pour définir et obtenir des données sur l’objet CTIOperationResponse actuel.

    Vous utilisez des objets CTIOperationResponse pour transmettre des informations entre un gestionnaire d’opération et un transformateur de message dans le cadre de ServiceNow Fonctions vocales travail.

    En règle générale, un gestionnaire d’opération est responsable de la définition des valeurs sur l’objet CTIOperationResponse lorsqu’il traite la demande associée. Un transformateur de message est ensuite chargé d’obtenir les valeurs de l’objet CTIOperationRequest et de construire la charge utile spécifique à CTI qui est renvoyée au fournisseur d’intégrateur de téléphonie informatique (CTI).

    Le ServiceNow système de base fournit des gestionnaires d’opérations et des transformateurs de message fonctionnels qui permettent la connexion à Amazon Connect. Lors de la création de flux de contacts dans Amazon Connect, il existe deux points d’intégration entre les services Amazon et une ServiceNow instance :
    • Proxy Lambda Amazon Web Services (AWS) (invoquer la fonction AWS Lambda)
    • Bot AWS Lex (obtenir l’entrée du client)
    Vous pouvez trouver les gestionnaires d’opérations et les transformateurs de message disponibles pour ces points d’intégration dans les tables Gestionnaires d’opérations [sn_cti_operation_handler] et Transformateur de message de fournisseur [sn_cti_provider_msg_transormer].

    Le script de gestionnaire d’opération suivant montre comment utiliser diverses méthodes CTIOperationResponse pour définir des valeurs sur l’objet CTIOperationResponse.

    (function(/*CTIOperationRequest*/ request, /*CTIOperationResponse*/ response) {

  try {
    var state = request.getParameter('$state');
    if(!state) {
      state = 'new';
    }
    var phone = request.getParameter('contact.phone');
    var username = request.getParameter('contact.username');
    var someDataPresent = phone || username;
    if(!someDataPresent) {
      throw 'phone or username must be supplied';
    }
    if('new' === state) {
      var userGr = null;
      if(phone || username) {
        userGr = new GlideRecordSecure('sys_user');
        var qc = null;
        if(phone) {
          qc = userGr.addQuery('phone', phone);
          qc.addOrCondition('mobile_phone', phone);
          qc.addOrCondition("home_phone", phone);
        }
        if(username) {
          if(qc) {
            qc.addOrCondition('user_name', username);
          } else {
            qc = userGr.addQuery('user_name', username);
          }
        }
        // If there was criteria then run the query
        if(qc) {
          userGr.query();
        } else {
          userGr = null;
        }
      }
			
      var foundUser = userGr && userGr.next();

      var phonelogGr = new GlideRecord('sn_openframe_phone_log');
      phonelogGr.initialize();
      phonelogGr.setValue('call_id', request.getParameter('contact.id'));
      phonelogGr.setValue('phone_number', phone);
      if(foundUser) {
        phonelogGr.setValue('contact', userGr.getUniqueValue());
      }
      phonelogGr.insert();
			
      var interactionGr = new GlideRecordSecure('interaction');
      interactionGr.initialize();
      interactionGr.setValue('type', 'phone');
      interactionGr.setValue('short_description', 'User Contact via Phone: ' + phone);
      interactionGr.setValue('channel_metadata_table', 'sn_openframe_phone_log');
      interactionGr.setValue('channel_metadata_document',phonelogGr.getUniqueValue());
			
      if(foundUser) {
        interactionGr.setValue('opened_for', userGr.getUniqueValue());
        response.setSessionAttribute('snc_user_first_name', userGr.getValue('first_name'));
        response.setSessionAttribute('snc_user_last_name', userGr.getValue('last_name'));
        response.setSessionAttribute('snc_user_sys_id', userGr.getUniqueValue());
      } else {
        response.setSessionAttribute('snc_user_sys_id', "USER_NOT_FOUND");
      }
      interactionGr.setValue('state', 'new');

      var interactionId = interactionGr.insert();

      response.setStatusCode(200);
      response.setMessage('success');
      response.setSessionAttribute('interactionTable', 'interaction');
      response.setSessionAttribute('interactionId', interactionId);

    }
  } catch(e) {
    ctx.setError(e);
  }

})(request, response);

    Pour plus d’informations sur la création de gestionnaires d’opérations, consultez Configurer un flux de contact pour une interaction automatisée de l’appelant.

    Le script de transformateur de message suivant obtient les valeurs définies sur l’objet CTIOperationResponse et les stocke dans la charge utile spécifique à CTI qui est ensuite renvoyée au fournisseur CTI.

    (function (/*CTIOperationResponse*/operationResponse, /*HTTPResponse*/ httpResponse) {
	// AWS Connect Lambda expects name value pairs only
	var out = {};
	for(var k in operationResponse.getSessionAttributes()) {
		out[k] = operationResponse.getSessionAttributes()[k];
	}
	out.statusCode = operationResponse.getStatusCode();
	out.message = operationResponse.getMessage();
	httpResponse.setBody(out);
})(operationResponse, httpResponse);

    Cet include de script s’exécute dans l’espace de noms sn_cti_core . Avant de pouvoir accéder à l’include de script CTIOperationRequest , le module d’extension ServiceNow Fonctions vocales Core (sn_cti_core) doit être installé. Pour en savoir plus sur l’installation, reportez-vous à la rubrique Installer les applications vocales ServiceNow.

    Pour en savoir plus sur , ServiceNow Fonctions vocalesconsultez Fonctions vocales ServiceNow.

    CTIOperationResponse : CTIOperationResponse (origine de la chaîne)

    Instancie un objet CTIOperationResponse.

    Tableau 1. Paramètres
    Nom Type Description
    Néant 
    var response = new sn_cti_core.CTIOperationResponse();
response.setMinorVersion(3);

    CTIOperationResponse : getAuthToken()

    Renvoie le jeton d’authentification qui a été défini sur l’objet CTIOperationResponse.

    Ce jeton est utilisé par l’infrastructure ServiceNow Fonctions vocales pour authentifier l’utilisateur actuel ServiceNow Fonctions vocales avant d’exécuter le gestionnaire d’opération demandé si le marqueur du auth_required gestionnaire est défini sur vrai. Le auth_required marqueur est un champ de la table Gestionnaire d’opération [sn_cti_operation_handler]. La durée de vie d’un jeton d’authentification doit couvrir la durée de vie de la session d’appel, mais elle est déterminée par le fournisseur CTI.

    Vous pouvez définir toute opération d’authentification/d’autorisation requise par votre implémentation en créant votre propre gestionnaire d’opération d’authentification. Quelle que soit la façon dont le jeton d’authentification est généré, le traducteur de message doit renvoyer le jeton dans la charge utile CTI. En outre, le fournisseur CTI doit stocker ce jeton d’authentification localement et le transmettre dans chaque demande d’opération qui nécessite une authentification.

    Si vous utilisez l’instance fournie Authentifier le gestionnaire d’opération, le gestionnaire lance la création du jeton d’authentification sur la base d’un code PIN saisi par l’utilisateur à quatre chiffres. Il définit ensuite le jeton d’authentification dans l’objet sessionAttributes de l’objet CTIOperationResponse. Le transformateur de message associé traduit l’objet sessionAttributes en charge utile spécifique au CTI, puis l’envoie au fournisseur CTI.

    Remarque :
    Si le jeton d’authentification n’est pas transmis, toutes les demandes d’exécution de gestionnaires d’opérations avec le auth_required marqueur défini échoueront. Si vous n’utilisez pas l’authentification, vous n’avez pas besoin de conserver les jetons d’authentification.
    Le ServiceNow système de base fournit des gestionnaires d’opérations et des transformateurs de message fonctionnels qui permettent la connexion à Amazon Connect. Lors de la création de flux de contacts dans Amazon Connect, il existe deux points d’intégration entre les services Amazon et une ServiceNow instance :
    • Proxy Lambda Amazon Web Services (AWS) (invoquer la fonction AWS Lambda)
    • Bot AWS Lex (obtenir l’entrée du client)
    Vous pouvez trouver les gestionnaires d’opérations et les transformateurs de message disponibles pour ces points d’intégration dans les tables Gestionnaires d’opérations [sn_cti_operation_handler] et Transformateur de message de fournisseur [sn_cti_provider_msg_transormer].
    Tableau 2. Paramètres
    Nom Type Description
    Aucun
    Tableau 3. Renvoie
    Type Description
    Chaîne Le jeton d’authentification précédemment défini sur l’objet CTIOperationRequest. Si cette option n’est pas définie, elle renvoie la valeur null. 
    var response = new sn_cti_core.CTIOperationResponse();
var token = response.getAuthToken();

    CTIOperationResponse : getError()

    Renvoie l’objet d’erreur associé à l’objet CTIOperationResponse actuel.

    Vous pouvez utiliser ces informations pour formuler la charge utile renvoyée au fournisseur d’intégration téléphonie-informatique (CTI).

    Tableau 4. Paramètres
    Nom Type Description
    Aucun
    Tableau 5. Renvoie
    Type Description
    Objet Informations sur l’erreur de fonctionnement. Le format de cet objet est déterminé par le fournisseur de CTI. Si une erreur n’existe pas, renvoie null. 
    (function( /*CTIProviderResponseExecutionContext*/ ctx, /*CTIOperationRequest*/ operationRequest, /*CTIOperationResponse*/ operationResponse, /*HTTPResponse*/ httpResponse) {
    var sessionAttributes = {},
        intentResponse;
    var statusCode = -1;
    var message = 'Unprocessed';
    if (operationResponse) {
        statusCode = operationResponse.getStatusCode();
        sessionAttributes = operationResponse.getSessionAttributes();
        message = operationResponse.getMessage();
        var error = operationResponse.getError();
        if (error) {
            sessionAttributes.error = error;
        }
    }
    if (sn_cti_core.CTIRequestDispatcher.Constants.HTTP.Status.AUTH_REQUIRED.code === statusCode) {
        //first call for a secure action without authentication token
        sessionAttributes.statusCode = 401;
        sessionAttributes.message = message;
        intentResponse = {
            sessionAttributes: sessionAttributes,
            dialogAction: {
                type: 'Close',
                fulfillmentState: 'Fulfilled',
                message: {
                    contentType: 'PlainText',
                    content: 'This operation requires authentication. Say authenticate for authentication.'
                }
            }
        };
    } else if ('DialogCodeHook' === operationRequest.getParameter('$$invocationSource')) {
        //pass back authToken and interactionId
        sessionAttributes.authToken = operationRequest.getAuthToken();
        sessionAttributes.interactionId = operationRequest.getInteractionSysId();
		var originalSlots = operationRequest.getParameter('$$slots');
        var responseParameters = operationResponse ? operationResponse.getParameters() : {};
        responseParameters = responseParameters ? responseParameters : {};
        // See if we processing happened and we got a dialogAction
		var responseDialogAction = responseParameters['dialogAction'];
		// Default dialog action
        var dialogAction = {
            type: 'Delegate',
            slots: originalSlots
        };
		// If the response doesn't contain an override replay the inputs
        if (responseDialogAction) {
            // We bypassed dialoghook so delegate and pass through inputs
            dialogAction = responseDialogAction;
        }
        intentResponse = {
            sessionAttributes: sessionAttributes,
            dialogAction: dialogAction
        };
    } else {
        // Override required session attributes
        sessionAttributes.statusCode = statusCode;
        sessionAttributes.message = message;
        // Build response template
        intentResponse = {
            sessionAttributes: sessionAttributes,
            dialogAction: {
                type: 'Close',
                fulfillmentState: 'Fulfilled',
                message: {
                    contentType: 'PlainText',
                    content: message
                }
            }
        };
    }
    httpResponse.setBody(intentResponse);
})(ctx, operationRequest, operationResponse, httpResponse);

    CTIOperationResponse : getInteractionSysId()

    Renvoie l’sys_id de l’enregistrement d’interaction associé à la session d’appel qui a été définie sur l’objet CTIOperationResponse.

    La méthode CTIOperationResponse : setInteractionSysId(String Id) doit avoir été appelée avant d’appeler cette méthode.

    Tableau 6. Paramètres
    Nom Type Description
    Aucun
    Tableau 7. Renvoie
    Type Description
    Chaîne Sys_id de l’ensemble d’enregistrements d’interaction sur l’objet CTIOperationResponse.

    Si la sys_id d’enregistrement d’interaction n’est pas définie, la méthode renvoie null.

    Table : Interaction [interaction]

    		 
    var request = new sn_cti_core.CTIOperationResponse();
var interactionId = request.getInteractionSysId();

    CTIOperationResponse : getMajorVersion()

    Renvoie la version majeure du logiciel d’intégrateur de téléphonie-informatique (CTI) défini sur l’objet CTIOperationResponse actuel.

    Utilisez cette méthode si les fournisseurs CTI connectés à votre ServiceNow instance exécutent plusieurs versions de leur logiciel, car différentes versions logicielles peuvent nécessiter des charges utiles différentes. Si la charge utile n’est que légèrement différente entre les versions logicielles, il peut être judicieux de n’avoir qu’un seul transformateur de message. Vous pouvez ensuite gérer les différences de charge utile en vérifiant simplement la version du logiciel effectuant la demande dans votre transformateur de message. Si la charge utile requise est significativement différente d’une version à l’autre, il peut être plus efficace d’utiliser plusieurs transformateurs de message.

    Tableau 8. Paramètres
    Nom Type Description
    Aucun
    Tableau 9. Renvoie
    Type Description
    Numéro Numéro de version majeure du logiciel CTI.

    Si la version majeure n’a jamais été définie, renvoie 1.

    		 
    var request = new sn_cti_core.CTIOperationResponse();
var majorVersion = response.getMajorVersion();

    CTIOperationResponse : getMessage()

    Renvoie la chaîne de message définie sur l’objet CTIOperationResponse actuel.

    En règle générale, il s’agit d’un message qui est renvoyé à l’utilisateur une fois qu’une opération est terminée. Vous pouvez définir cette valeur à l’aide de la méthode CTIOperationResponse - setMessage(String message).

    Tableau 10. Paramètres
    Nom Type Description
    Aucun
    Tableau 11. Renvoie
    Type Description
    Chaîne Texte du message. Si aucun message n’existe, renvoie null. 
    (function (/*CTIOperationResponse*/operationResponse, /*HTTPResponse*/ httpResponse) {
  // AWS Connect Lambda expects name value pairs only
  var out = {};
  for(var k in operationResponse.getSessionAttributes()) {
    out[k] = operationResponse.getSessionAttributes()[k];
  }
  out.statusCode = operationResponse.getStatusCode();
  out.message = operationResponse.getMessage();
  httpResponse.setBody(out);
})(operationResponse, httpResponse);

    CTIOperationResponse : getMinorVersion()

    Renvoie la version mineure du logiciel d’intégrateur téléphonie-informatique (CTI) définie sur l’objet CTIOperationResponse actuel.

    Utilisez cette méthode si les fournisseurs CTI connectés à votre ServiceNow instance exécutent plusieurs versions de leur logiciel, car différentes versions logicielles peuvent nécessiter des charges utiles différentes. Si la charge utile n’est que légèrement différente entre les versions logicielles, il peut être judicieux de n’avoir qu’un seul transformateur de message. Vous pouvez ensuite gérer les différences de charge utile en vérifiant simplement la version du logiciel effectuant la demande dans votre transformateur de message. Si la charge utile requise est significativement différente d’une version à l’autre, il peut être plus efficace d’utiliser plusieurs transformateurs de message.

    Tableau 12. Paramètres
    Nom Type Description
    Aucun
    Tableau 13. Renvoie
    Type Description
    Numéro Numéro de version mineure de la charge utile associée à cette interaction.

    Si la version mineure n’a jamais été définie, renvoie la valeur 0.

    		 
    var request = new sn_cti_core.CTIOperationResponse();
var minorVersion = request.getMinorVersion();

    CTIOperationResponse : getParameter(clé de chaîne)

    Renvoie la valeur d’une clé spécifiée précédemment définie sur l’objet CTIOperationResponse actuel.

    L’utilisation des méthodes de paramètre get/set permet le passage de pratiquement n’importe quelle valeur de chaîne ou de numéro entre un gestionnaire d’opération et un transformateur de message. L’objet de paramètre peut contenir zéro ou plusieurs paires clé/valeur de données directement corrélées à la réponse de l’opération en cours. Le gestionnaire de l’opération détermine quelles paires clé/valeur sont requises lorsqu’il produit ces valeurs. Utilisez la méthode CTIOperationResponse - setParameter(String key, Object value) pour définir les paramètres de l’objet CTIOperationResponse actuel.

    Tableau 14. Paramètres
    Nom Type Description
    clé Chaîne Le nom de la valeur de clé à renvoyer.
    Tableau 15. Renvoie
    Type Description
    Chaîne Valeur de la clé transmise. En l’absence d’une telle clé, elle renvoie null. 
    var request = new sn_cti_core.CTIOperationResponse();
var parm = request.getParameter('contact.phone');

    CTIOperationResponse : getParameters()

    Renvoie les paires clé-valeur de tous les paramètres qui ont été définis précédemment sur l’objet CTIOperationResponse actuel.

    L’utilisation des méthodes de paramètre get/set permet le passage de pratiquement n’importe quelle valeur de chaîne ou de numéro entre un gestionnaire d’opération et un transformateur de message. L’objet de paramètre peut contenir zéro ou plusieurs paires clé/valeur de données directement corrélées à la réponse de l’opération en cours. Le gestionnaire de l’opération détermine quelles paires clé/valeur sont requises lorsqu’il produit ces valeurs. Utilisez la méthode CTIOperationResponse - setParameter(String key, Object value) pour définir les paramètres de l’objet CTIOperationResponse actuel.

    Tableau 16. Paramètres
    Nom Type Description
    Aucun
    Tableau 17. Renvoie
    Type Description
    Objet Carte des paires clé-valeur précédemment définies sur l’objet CTIOperationResponse. Ces paires clé-valeur sont de forme libre et définies par les besoins du gestionnaire de l’opération. Les valeurs renvoyées sont soit des chaînes, soit des nombres. 
    (function( /*CTIProviderResponseExecutionContext*/ ctx, /*CTIOperationRequest*/ operationRequest, /*CTIOperationResponse*/ operationResponse, /*HTTPResponse*/ httpResponse) {
  var sessionAttributes = {},
      intentResponse;
  var statusCode = -1;
  var message = 'Unprocessed';
  if (operationResponse) {
    statusCode = operationResponse.getStatusCode();
    sessionAttributes = operationResponse.getSessionAttributes();
    message = operationResponse.getMessage();
    var error = operationResponse.getError();
    if (error) {
      sessionAttributes.error = error;
    }
  }
  if (sn_cti_core.CTIRequestDispatcher.Constants.HTTP.Status.AUTH_REQUIRED.code === statusCode) {
    //first call for a secure action without authentication token
    sessionAttributes.statusCode = 401;
    sessionAttributes.message = message;
    intentResponse = {
      sessionAttributes: sessionAttributes,
      dialogAction: {
        type: 'Close',
        fulfillmentState: 'Fulfilled',
        message: {
          contentType: 'PlainText',
          content: 'This operation requires authentication. Say authenticate for authentication.'
        }
      }
    };
  } else if ('DialogCodeHook' === operationRequest.getParameter('$$invocationSource')) {
      //pass back authToken and interactionId
      sessionAttributes.authToken = operationRequest.getAuthToken();
      sessionAttributes.interactionId = operationRequest.getInteractionSysId();
      var originalSlots = operationRequest.getParameter('$$slots');
      var responseParameters = operationResponse ? operationResponse.getParameters() : {};
      responseParameters = responseParameters ? responseParameters : {};
      // See if processing happened and we got a dialogAction
      var responseDialogAction = responseParameters['dialogAction'];
      // Default dialog action
      var dialogAction = {
        type: 'Delegate',
        slots: originalSlots
      };
      // If the response doesn't contain an override replay the inputs
      if (responseDialogAction) {
        // We bypassed dialoghook so delegate and pass through inputs
        dialogAction = responseDialogAction;
      }
        intentResponse = {
            sessionAttributes: sessionAttributes,
            dialogAction: dialogAction
        };
    } else {
      // Override required session attributes
      sessionAttributes.statusCode = statusCode;
      sessionAttributes.message = message;
      // Build response template
      intentResponse = {
        sessionAttributes: sessionAttributes,
        dialogAction: {
          type: 'Close',
          fulfillmentState: 'Fulfilled',
          message: {
            contentType: 'PlainText',
            content: message
          }
        }
      };
  }
  httpResponse.setBody(intentResponse);
})(ctx, operationRequest, operationResponse, httpResponse);

    CTIOperationResponse : getSessionAttribute(clé de chaîne)

    Renvoie la valeur d’une clé d’attribut de session spécifiée définie sur l’objet CTIOperationResponse actuel.

    L’utilisation des méthodes d’attribut de session get/set permet de transmettre pratiquement n’importe quelle valeur de chaîne ou de numéro entre un gestionnaire d’opération et un transformateur de message. Les attributs de session sont également accessibles dans un flux de contact. L’objet sessionAttribute peut contenir zéro ou plusieurs paires clé/valeur de données, telles que le numéro de téléphone du contact, qui sont valides pendant la durée d’une session définie par le fournisseur de couplage téléphonie-informatique. Le gestionnaire des opérations détermine les paires clé/valeur d’attribut de session nécessaires car il utilise ces valeurs pendant le traitement. En règle générale, le gestionnaire d’opération définit ces attributs sur l’objet CTIOperationResponse en appelant la méthode CTIOperationResponse - setSessionAttribute (clé de chaîne, valeur d’objet) et le transformateur de message consomme les attributs à l’aide de cette méthode.

    Tableau 18. Paramètres
    Nom Type Description
    clé Chaîne Le nom de la valeur de clé à renvoyer.
    Tableau 19. Renvoie
    Type Description
    Chaîne Valeur de la clé transmise. En l’absence d’une telle clé, elle renvoie null. 
    var response = new sn_cti_core.CTIOperationResponse();
var phoneAttribute = response.getSessionAttribute('contact.phone');

    CTIOperationResponse : getSessionAttributes()

    Renvoie les paires clé-valeur de tous les attributs de session qui étaient précédemment définis sur l’objet CTIOperationResponse actuel.

    L’utilisation des méthodes d’attribut de session get/set permet de transmettre pratiquement n’importe quelle valeur de chaîne ou de numéro entre un gestionnaire d’opération et un transformateur de message. Les attributs de session sont également accessibles dans un flux de contact. L’objet sessionAttribute peut contenir zéro ou plusieurs paires clé/valeur de données, telles que le numéro de téléphone du contact, qui sont valides pendant la durée d’une session définie par le fournisseur de couplage téléphonie-informatique. Le gestionnaire des opérations détermine les paires clé/valeur d’attribut de session nécessaires car il utilise ces valeurs pendant le traitement. En règle générale, le gestionnaire d’opération définit ces attributs sur l’objet CTIOperationResponse en appelant la méthode CTIOperationResponse - setSessionAttribute (clé de chaîne, valeur d’objet) et le transformateur de message consomme les attributs à l’aide de cette méthode.

    Tableau 20. Paramètres
    Nom Type Description
    Aucun
    Tableau 21. Renvoie
    Type Description
    Objet Carte des paires clé-valeur précédemment définies sur l’objet CTIOperationResponse. Ces paires clé-valeur sont de forme libre et définies par les besoins du gestionnaire de l’opération. Les valeurs renvoyées sont soit des chaînes, soit des nombres. 
    (function (/*CTIOperationResponse*/operationResponse, /*HTTPResponse*/ httpResponse) {
  // AWS Connect Lambda expects name value pairs only
  var out = {};
  for(var k in operationResponse.getSessionAttributes()) {
    out[k] = operationResponse.getSessionAttributes()[k];
  }
  out.statusCode = operationResponse.getStatusCode();
  out.message = operationResponse.getMessage();
  httpResponse.setBody(out);
})(operationResponse, httpResponse);

    CTIOperationResponse : getStatusCode()

    Renvoie le code d’état défini sur l’objet CTIOperationResponse actuel.

    Ces codes d’état doivent correspondre aux codes d’état HTTP standard, tels que 200 pour réussite, 401 pour autorisation requise. En règle générale, les codes d’état résultants sont déterminés par le gestionnaire d’opération et sont définis sur l’objet CTIOperationResponse à l’aide de la méthode CTIOperationResponse - setStatusCode(String, statusCode). Le transformateur de message utilise ensuite cette méthode pour inclure le code d’état dans la charge utile renvoyée au fournisseur d’intégrateur de téléphonie.

    Tableau 22. Paramètres
    Nom Type Description
    Aucun
    Tableau 23. Renvoie
    Type Description
    Numéro Code d’état de l’opération en cours. Si aucun code d’état n’a été défini, renvoie -1. 
    (function (/*CTIOperationResponse*/operationResponse, /*HTTPResponse*/ httpResponse) {
  // AWS Connect Lambda expects name value pairs only
  var out = {};
  for(var k in operationResponse.getSessionAttributes()) {
    out[k] = operationResponse.getSessionAttributes()[k];
  }
  out.statusCode = operationResponse.getStatusCode();
  out.message = operationResponse.getMessage();
  httpResponse.setBody(out);
})(operationResponse, httpResponse);

    CTIOperationResponse : setAuthToken(jeton de chaîne)

    Définit un jeton d’authentification sur l’objet CTIOperationResponse actuel.

    Ce jeton est utilisé par l’infrastructure ServiceNow Fonctions vocales pour authentifier l’utilisateur actuel ServiceNow Fonctions vocales avant d’exécuter le gestionnaire d’opération demandé si le marqueur du auth_required gestionnaire est défini sur vrai. Le auth_required marqueur est un champ de la table Gestionnaire d’opération [sn_cti_operation_handler]. La durée de vie d’un jeton d’authentification doit couvrir la durée de vie de la session d’appel, mais elle est déterminée par le fournisseur CTI.

    Vous pouvez définir toute opération d’authentification/d’autorisation requise par votre implémentation en créant votre propre gestionnaire d’opération d’authentification. Quelle que soit la façon dont le jeton d’authentification est généré, le traducteur de message doit renvoyer le jeton dans la charge utile CTI. En outre, le fournisseur CTI doit stocker ce jeton d’authentification localement et le transmettre dans chaque demande d’opération qui nécessite une authentification.

    Si vous utilisez l’instance fournie Authentifier le gestionnaire d’opération, le gestionnaire lance la création du jeton d’authentification sur la base d’un code PIN saisi par l’utilisateur à quatre chiffres. Il définit ensuite le jeton d’authentification dans l’objet sessionAttributes de l’objet CTIOperationResponse. Le transformateur de message associé traduit l’objet sessionAttributes en charge utile spécifique au CTI, puis l’envoie au fournisseur CTI.

    Remarque :
    Si le jeton d’authentification n’est pas transmis, toutes les demandes d’exécution de gestionnaires d’opérations avec le auth_required marqueur défini échoueront. Si vous n’utilisez pas l’authentification, vous n’avez pas besoin de conserver les jetons d’authentification.
    Le ServiceNow système de base fournit des gestionnaires d’opérations et des transformateurs de message fonctionnels qui permettent la connexion à Amazon Connect. Lors de la création de flux de contacts dans Amazon Connect, il existe deux points d’intégration entre les services Amazon et une ServiceNow instance :
    • Proxy Lambda Amazon Web Services (AWS) (invoquer la fonction AWS Lambda)
    • Bot AWS Lex (obtenir l’entrée du client)
    Vous pouvez trouver les gestionnaires d’opérations et les transformateurs de message disponibles pour ces points d’intégration dans les tables Gestionnaires d’opérations [sn_cti_operation_handler] et Transformateur de message de fournisseur [sn_cti_provider_msg_transormer].
    Tableau 24. Paramètres
    Nom Type Description
    Aucun
    Tableau 25. Renvoie
    Type Description
    Chaîne Le jeton d’authentification à utiliser pour authentifier les opérations qui ont le auth_required marqueur défini. 
    var response = new sn_cti_core.CTIOperationResponse();
var authenticate = <Your authentication code here>; // Authenticate the user
if (authenticated) {
	var claims = {
		"interactionId":interactionGr.sys_id.toString()
	};
	var jwt = new sn_cti_core.AuthHelpers().generateJWT(claims);
	response.setAuthToken(jwt);
}

    CTIOperationResponse : setError(Object error)

    Définit l’objet d’erreur dans l’objet CTIOperationResponse actuel.

    Vous pouvez utiliser l’objet d’erreur dans le composant pour formuler la charge utile à envoyer au fournisseur d’intégrateur téléphonie-informatique (CTI).

    Tableau 26. Paramètres
    Nom Type Description
    erreur Objet Informations sur l’erreur détectée lors du traitement de l’opération demandée. Le format de cet objet est déterminé par le fournisseur de CTI.
    Tableau 27. Renvoie
    Type Description
    nul 
    var response = new sn_cti_core.CTIOperationResponse();
response.setError(new Error("You did not supply a field"));

    CTIOperationResponse : setInteractionSysId(Id de chaîne)

    Définit le sys_id de l’enregistrement d’interaction associé à la demande d’opération sur l’objet CTIOperationResponse actuel.

    Tableau 28. Paramètres
    Nom Type Description
    sys_id Chaîne La sys_id à définir pour l’interaction en cours.
    Tableau 29. Renvoie
    Type Description
    nul 
    var response = new sn_cti_core.CTIOperationResponse();
response.setInteractionSysId('98529cc55380001048e5ddeeff7b120b');

    CTIOperationResponse : setMajorVersion(Number majorVersion)

    Définit la version majeure du logiciel du fournisseur d’intégrateur téléphonie-informatique (CTI) qui effectue la demande sur l’objet CTIOperationResponse associé.

    Utilisez cette méthode si les fournisseurs CTI connectés à votre ServiceNow instance exécutent plusieurs versions de leur logiciel, car différentes versions logicielles peuvent nécessiter des charges utiles différentes. Si la charge utile n’est que légèrement différente entre les versions logicielles, il peut être judicieux de n’avoir qu’un seul transformateur de message. Vous pouvez ensuite gérer les différences de charge utile en vérifiant simplement la version du logiciel effectuant la demande dans votre transformateur de message. Si la charge utile requise est significativement différente d’une version à l’autre, il peut être plus efficace d’utiliser plusieurs transformateurs de message.

    Tableau 30. Paramètres
    Nom Type Description
    majorVersion Numéro Version majeure du logiciel du fournisseur CTI effectuant la demande d’opération.

    Si cette valeur n’a pas été définie précédemment, renvoie 1.
    Tableau 31. Renvoie
    Type Description
    nul 
    var request = new sn_cti_core.CTIOperationResponse();
request.setMajorVersion(2);

    CTIOperationResponse : setMessage(Message de chaîne)

    Définit un message texte sur l’objet CTIOperationResponse actuel.

    En règle générale, il s’agit d’un message renvoyé à l’utilisateur une fois qu’une opération est terminée et défini par le gestionnaire d’opération associé. Le transformateur de message utilise ensuite la méthode CTIOperationResponse - getMessage() pour obtenir le message et le renvoyer au fournisseur d’intégration téléphonie-informatique.

    Tableau 32. Paramètres
    Nom Type Description
    message Chaîne Texte du message
    Tableau 33. Renvoie
    Type Description
    nul 
    (function(/*CTIOperationRequest*/ request, /*CTIOperationResponse*/ response, /*Context*/ ctx) {	
  var notes = '', lang = request.getLanguage();
  try { 
		
    var interactionGr = request.getInteractionRecord();

    var now_GR = new GlideRecord('sys_user');
    if(interactionGr && now_GR.get(interactionGr.opened_for.toString())) {	
    if(now_GR.locked_out == true) {
        notes += gs.getMessageLang("User record found locked. Unlocking the account.\n", lang);
        now_GR.locked_out=false;
        now_GR.update();
        response.setStatusCode(200);
        response.setMessage(gs.getMessageLang("Your account has been unlocked.", lang));
      } else {
        notes += gs.getMessageLang("User record not locked.\n", lang);
        response.setStatusCode(200);
        response.setMessage(gs.getMessageLang("Your account doesn't seem to be locked.", lang));
      }	
    } else {
      notes += gs.getMessageLang("User record not found. Transfer to agent\n", lang);
      response.setStatusCode(302);
      response.setMessage(gs.getMessageLang("I am unable to find your record. Let me transfer to someone who can help.", lang));
    }
    if(interactionGr) {
      interactionGr.work_notes = notes;
      interactionGr.update();
    }
  } catch(e) {
    ctx.setError(e);
  }
})(request, response, ctx);

    CTIOperationResponse : setMinorVersion(Number minorVersion)

    Définit la version mineure du logiciel du fournisseur d’intégrateur téléphonie-informatique (CTI) effectuant la demande sur l’objet CTIOperationResponse associé.

    Utilisez cette méthode si les fournisseurs CTI connectés à votre ServiceNow instance exécutent plusieurs versions de leur logiciel, car différentes versions logicielles peuvent nécessiter des charges utiles différentes. Si la charge utile n’est que légèrement différente entre les versions logicielles, il peut être judicieux de n’avoir qu’un seul transformateur de message. Vous pouvez ensuite gérer les différences de charge utile en vérifiant simplement la version du logiciel effectuant la demande dans votre transformateur de message. Si la charge utile requise est significativement différente d’une version à l’autre, il peut être plus efficace d’utiliser plusieurs transformateurs de message.

    Tableau 34. Paramètres
    Nom Type Description
    minorVersion Numéro Version mineure du logiciel du fournisseur CTI effectuant la demande d’opération.

    Si cette valeur n’a pas été définie précédemment, renvoie 0.
    Tableau 35. Renvoie
    Type Description
    nul 
    var response = new sn_cti_core.CTIOperationResponse();
response.setMinorVersion(3);

    CTIOperationResponse : setParameter(clé de chaîne, valeur d’objet)

    Définit la paire clé-valeur spécifiée sur l’objet CTIOperationResponse associé.

    L’utilisation des méthodes de paramètre get/set permet le passage de pratiquement n’importe quelle valeur de chaîne ou de numéro entre un gestionnaire d’opération et un transformateur de message. L’objet de paramètre peut contenir zéro ou plusieurs paires clé/valeur de données directement corrélées à la demande d’opération en cours. Le gestionnaire de l’opération détermine quelles paires clé/valeur sont requises lorsqu’il consomme ces valeurs. En règle générale, le gestionnaire d’opération définit ces paramètres sur l’objet CTIOperationResponse en appelant cette méthode et le transformateur de message les utilise à l’aide de la méthode CTIOperationResponse - getParmeter(String key) ou CTIOperationResponse - getSParameters().

    Remarque :
    Vous ne devez stocker que les objets qui peuvent survivre à une opération JSON.parse(JSON.stringify(object)). Les objets ne répondant pas à ces critères peuvent ne pas se propager correctement tout au long de la chaîne de traitement de l’opération.
    Par exemple :
    var x = {
  "string": 'abc',
  "int": 123,
  "float": 1.234,
  "number": new Number(3),
  "boolean": true,
  "date": new Date(2006, 0, 2, 15, 4, 5),
  "object": {
    "string": 'abc',
    "int": 123,
    "float": 1.234,
    "number": new Number(3),
    "boolean": true,
    "date": new Date(2006, 0, 2, 15, 4, 5)
  },
  "function": function(abc) {

  }
}
var stringify = JSON.stringify(x);
gs.info(stringify);
var hydrate = JSON.parse(stringify);
var stringify2 = JSON.stringify(hydrate);
gs.info(stringify2);
    Produit:
    {"string":"abc","int":123,"float":1.234,"number":3,"boolean":true,"date":"2006-01-02T23:04:05.000Z","object":{"string":"abc","int":123,"float":1.234,"number":3,"boolean":true,"date":"2006-01-02T23:04:05.000Z"}}
{"string":"abc","int":123,"float":1.234,"number":3,"boolean":true,"date":"2006-01-02T23:04:05.000Z","object":{"string":"abc","int":123,"float":1.234,"number":3,"boolean":true,"date":"2006-01-02T23:04:05.000Z"}}
    Tableau 36. Paramètres
    Nom Type Description
    clé Chaîne Nom de la clé sous laquelle stocker la valeur associée.
    valide Objet Valeur à stocker pour la clé.
    Types de données valides :
    • chaîne
    • int
    • flottant
    • Numéro
    • booléen
    • date
    • objet
    Tableau 37. Renvoie
    Type Description
    nul 
    var response = new sn_cti_core.CTIOperationResponse();
response.setParameter('contact.phone', '+15552222345');
response.setParameter('contact.okToCall', true);
response.setParameter('contact.address', {
    street: '1234 Main St'
    city: 'API City',
    zip: 91335
});

    CTIOperationResponse : setSessionAttribute(Clé de chaîne, valeur d’objet)

    Définit la paire clé-valeur d’attribut de session spécifiée sur l’objet CTIOperationResponse associé.

    L’utilisation des méthodes d’attribut de session get/set permet de transmettre pratiquement n’importe quelle valeur de chaîne ou de numéro entre un gestionnaire d’opération et un transformateur de message. L’objet sessionAttribute peut contenir zéro ou plusieurs paires clé/valeur de données valides pendant la durée d’une session définie par le fournisseur d’intégration téléphonie-informatique. Les attributs de session sont également accessibles dans un flux de contact. Le gestionnaire des opérations détermine les paires clé/valeur d’attribut de session nécessaires lorsqu’il consomme ces valeurs. En règle générale, le gestionnaire d’opération définit ces attributs sur l’objet CTIOperationResponse en appelant cette méthode et le transformateur de message obtient les attributs à l’aide de la méthode CTIOperationResponse - getSessionAttribute(String key) ou CTIOperationResponse - getSessionAttribute().

    Remarque :
    Vous ne devez stocker que les objets qui peuvent survivre à une opération JSON.parse(JSON.stringify(object)). Les objets ne répondant pas à ces critères peuvent ne pas se propager correctement tout au long de la chaîne de traitement de l’opération.
    Par exemple :
    var x = {
  "string": 'abc',
  "int": 123,
  "float": 1.234,
  "number": new Number(3),
  "boolean": true,
  "date": new Date(2006, 0, 2, 15, 4, 5),
  "object": {
    "string": 'abc',
    "int": 123,
    "float": 1.234,
    "number": new Number(3),
    "boolean": true,
    "date": new Date(2006, 0, 2, 15, 4, 5)
  },
  "function": function(abc) {

  }
}
var stringify = JSON.stringify(x);
gs.info(stringify);
var hydrate = JSON.parse(stringify);
var stringify2 = JSON.stringify(hydrate);
gs.info(stringify2);
    Produit:
    {"string":"abc","int":123,"float":1.234,"number":3,"boolean":true,"date":"2006-01-02T23:04:05.000Z","object":{"string":"abc","int":123,"float":1.234,"number":3,"boolean":true,"date":"2006-01-02T23:04:05.000Z"}}
{"string":"abc","int":123,"float":1.234,"number":3,"boolean":true,"date":"2006-01-02T23:04:05.000Z","object":{"string":"abc","int":123,"float":1.234,"number":3,"boolean":true,"date":"2006-01-02T23:04:05.000Z"}}
    Tableau 38. Paramètres
    Nom Type Description
    clé Chaîne Nom de la clé d’attribut de session sous laquelle définir la valeur associée.
    valide Objet Valeur à définir.
    Types de données valides :
    • chaîne
    • int
    • flottant
    • Numéro
    • booléen
    • date
    • objet
    Tableau 39. Renvoie
    Type Description
    nul 
    var response = new sn_cti_core.CTIOperationResponse();
response.setSessionAttribute('contact.phone', '+15552222345');
response.setSessionAttribute('contact.okToCall', true);
response.setSessionAttribute('contact.address', {
    street: '1234 Main St'
    city: 'API City',
    zip: 91335
});

    CTIOperationResponse : setStatusCode(Number statusCode)

    Définit le code d’état de la demande d’opération en cours sur l’objet CTIOperationResponse.

    Vous pouvez utiliser n’importe quelle valeur entière pour définir l’état, mais il est recommandé d’émuler les codes d’état HTTP, tels que 200 = OK/Réussite, 400 = Demande incorrecte, 401 = Non autorisé.

    Tableau 40. Paramètres
    Nom Type Description
    statusCode Numéro Entier qui identifie de manière unique l’état de l’opération demandée.
    Tableau 41. Renvoie
    Type Description
    nul 
    (function(/*CTIOperationRequest*/ request, /*CTIOperationResponse*/ response, /*Context*/ ctx) {	
  var notes = '', lang = request.getLanguage();
  try { 
		
    var interactionGr = request.getInteractionRecord();

    var now_GR = new GlideRecord('sys_user');
    if(interactionGr && now_GR.get(interactionGr.opened_for.toString())) {	
    if(now_GR.locked_out == true) {
        notes += gs.getMessageLang("User record found locked. Unlocking the account.\n", lang);
        now_GR.locked_out=false;
        now_GR.update();
        response.setStatusCode(200);
        response.setMessage(gs.getMessageLang("Your account has been unlocked.", lang));
      } else {
        notes += gs.getMessageLang("User record not locked.\n", lang);
        response.setStatusCode(200);
        response.setMessage(gs.getMessageLang("Your account doesn't seem to be locked.", lang));
      }	
    } else {
      notes += gs.getMessageLang("User record not found. Transfer to agent\n", lang);
      response.setStatusCode(302);
      response.setMessage(gs.getMessageLang("I am unable to find your record. Let me transfer to someone who can help.", lang));
    }
    if(interactionGr) {
      interactionGr.work_notes = notes;
      interactionGr.update();
    }
  } catch(e) {
    ctx.setError(e);
  }
})(request, response, ctx);