Alexa Skill Basics: Service Client API

es-ES.json

{
  "interactionModel": {
    "languageModel": {
      "invocationName": "datos personales",
      "intents": [
        {
          "name": "AMAZON.CancelIntent",
          "samples": []
        },
        {
          "name": "AMAZON.HelpIntent",
          "samples": []
        },
        {
          "name": "AMAZON.StopIntent",
          "samples": []
        },
        {
          "name": "AMAZON.NavigateHomeIntent",
          "samples": []
        },
        {
          "name": "AddressIntent",
          "samples": [
            "quiero saber la dirección",
            "quiero saber mi dirección",
            "donde vivo",
            "cual es mi direccion",
            "dame mi dirección",
            "dime mi dirección",
            "donde estoy"
          ]
        },
        {
          "name": "TimeZoneIntent",
          "samples": [
            "quiero saber mi zona horaria",
            "quiero saber la zona horaria",
            "zona horaria",
            "en que zona horaria estoy",
            "que zona horaria tengo",
            "dime la zona horaria",
            "dame la zona horaria"
          ]
        },
        {
          "name": "TemperatureUnitIntent",
          "samples": [
            "temperatura",
            "unidad de temperatura",
            "dime mi unidad de temperatura",
            "cual es mi unidad de temperatura"
          ]
        },
        {
          "name": "DistanceUnitIntent",
          "samples": [
            "unidad de distancia",
            "dime mi unidad de distancia",
            "cual es mi unidad de distancia",
            "distancia"
          ]
        },
        {
          "name": "EmailIntent",
          "samples": [
            "cual es mi email",
            "dime mi email",
            "email",
            "cual es mi correo electrónico",
            "dime mi correo electrónico",
            "correo electrónico"
          ]
        },
        {
          "name": "MobileIntent",
          "samples": [
            "móvil",
            "teléfono",
            "número de móvil",
            "número de teléfono",
            "dime mi móvil",
            "dime mi número de teléfono",
            "cual es mi móvil",
            "cual es mi número de teléfono"
          ]
        },
        {
          "name": "NameIntent",
          "samples": [
            "como me llamo",
            "cual es mi nombre",
            "dime mi nombre",
            "nombre",
            "nombre completo"
          ]
        }
      ]
    }
  }
}

index.js

/* eslint-disable  func-names */
/* eslint-disable  no-console */

const Alexa = require('ask-sdk');

const LaunchHandler = {
  canHandle(handlerInput) {
    const request = handlerInput.requestEnvelope.request;
    return request.type === 'LaunchRequest';
  },
  handle(handlerInput) {
    const speechOutput = "¡Bienvenido! " + HELP_MESSAGE;

    return handlerInput.responseBuilder
      .speak(speechOutput)
      .reprompt(speechOutput)
      .getResponse();
  },
};

//https://ask-sdk-for-nodejs.readthedocs.io/en/latest/Calling-Alexa-Service-APIs.html#deviceaddressserviceclient
const AddressIntentHandler = {
  canHandle(handlerInput) {
    const { request } = handlerInput.requestEnvelope;

    return request.type === 'IntentRequest' && request.intent.name === 'AddressIntent';
  },
  async handle(handlerInput) {
    const { requestEnvelope, serviceClientFactory, responseBuilder } = handlerInput;

    const consentToken = requestEnvelope.context.System.user.permissions
      && requestEnvelope.context.System.user.permissions.consentToken;
    if (!consentToken) {
      return responseBuilder
        .speak(NOTIFY_MISSING_PERMISSIONS)
        .withAskForPermissionsConsentCard(ADDRESS_PERMISSION)
        .getResponse();
    }

    console.log('INFO: we have permission!');
    const { deviceId } = requestEnvelope.context.System.device;
    const deviceAddressServiceClient = serviceClientFactory.getDeviceAddressServiceClient();
    const address = await deviceAddressServiceClient.getFullAddress(deviceId);
    //const address = await deviceAddressServiceClient.getCountryAndPostalCode(deviceId);

    let response;
    if (address.addressLine1 === null && address.stateOrRegion === null) {
      response = responseBuilder.speak(NO_INFO).getResponse();
    } else {
      const ADDRESS_MESSAGE = `${ADDRESS_AVAILABLE + address.addressLine1}, ${address.city}, ${address.stateOrRegion}, ${address.postalCode}, código de país ${address.countryCode}`;
      response = responseBuilder.speak(ADDRESS_MESSAGE).reprompt('¿Quieres alguna otra información?').getResponse();
    }
    return response;
  }
};

const EmailIntentHandler = {
  canHandle(handlerInput) {
    return handlerInput.requestEnvelope.request.type === 'IntentRequest'
      && handlerInput.requestEnvelope.request.intent.name === 'EmailIntent';
  },
  async handle(handlerInput) {
    const { serviceClientFactory, responseBuilder } = handlerInput;
    try {
      const upsServiceClient = serviceClientFactory.getUpsServiceClient();
      const profileEmail = await upsServiceClient.getProfileEmail();
      if (!profileEmail) {
        return responseBuilder
                      .speak(NO_INFO)
                      .getResponse();
      }
      const speechResponse = `Tu email es ${profileEmail}`;
      return responseBuilder
                      .speak(speechResponse)
                      .reprompt('¿Quieres alguna otra información?')
                      .getResponse();
    } catch (error) {
      console.log(error.message);
      if (error.statusCode == 403) {
        return responseBuilder
        .speak(NOTIFY_MISSING_PERMISSIONS)
        .withAskForPermissionsConsentCard(EMAIL_PERMISSION)
        .getResponse();
      }
      console.log(JSON.stringify(error));
      const response = responseBuilder.speak(ERROR_MESSAGE).getResponse();
      return response;
    }
  }
}

const MobileIntentHandler = {
  canHandle(handlerInput) {
    return handlerInput.requestEnvelope.request.type === 'IntentRequest'
      && handlerInput.requestEnvelope.request.intent.name === 'MobileIntent';
  },
  async handle(handlerInput) {
    const { serviceClientFactory, responseBuilder } = handlerInput;
    try {
      const upsServiceClient = serviceClientFactory.getUpsServiceClient();
      const profileMobile = await upsServiceClient.getProfileMobileNumber();
      if (!profileMobile) {
        return responseBuilder
                      .speak(NO_INFO)
                      .getResponse();
      }
      const speechResponse = `Tu móvil es ${profileMobile}`;
      return responseBuilder
                      .speak(speechResponse)
                      .reprompt('¿Quieres alguna otra información?')
                      .getResponse();
    } catch (error) {
      console.log(error.message);
      if (error.statusCode == 403) {
        return responseBuilder
        .speak(NOTIFY_MISSING_PERMISSIONS)
        .withAskForPermissionsConsentCard(MOBILE_PERMISSION)
        .getResponse();
      }
      console.log(JSON.stringify(error));
      const response = responseBuilder.speak(ERROR_MESSAGE).getResponse();
      return response;
    }
  }
}

const NameIntentHandler = {
  canHandle(handlerInput) {
    return handlerInput.requestEnvelope.request.type === 'IntentRequest'
      && handlerInput.requestEnvelope.request.intent.name === 'NameIntent';
  },
  async handle(handlerInput) {
    const { serviceClientFactory, responseBuilder } = handlerInput;
    try {
      const upsServiceClient = serviceClientFactory.getUpsServiceClient();
      const profileName = await upsServiceClient.getProfileName();
      //const profileName = await upsServiceClient.getProfileGivenName();
      if (!profileName) {
        return responseBuilder
                      .speak(NO_INFO)
                      .getResponse();
      }
      const speechResponse = `Tu nombre es ${profileName}`;
      return responseBuilder
                      .speak(speechResponse)
                      .reprompt('¿Quieres alguna otra información?')
                      .getResponse();
    } catch (error) {
      console.log(error.message);
      if (error.statusCode == 403) {
        return responseBuilder
        .speak(NOTIFY_MISSING_PERMISSIONS)
        .withAskForPermissionsConsentCard(FULL_NAME_PERMISSION)
        //.withAskForPermissionsConsentCard(GIVEN_NAME_PERMISSION) //and in skill.json replace with alexa::profile:given_name:read
        .getResponse();
      }
      console.log(JSON.stringify(error));
      const response = responseBuilder.speak(ERROR_MESSAGE).getResponse();
      return response;
    }
  }
}

const TimeZoneIntentHandler = {
  canHandle(handlerInput) {
    return handlerInput.requestEnvelope.request.type === 'IntentRequest'
      && handlerInput.requestEnvelope.request.intent.name === 'TimeZoneIntent';
  },
  async handle(handlerInput) {
    const { requestEnvelope, serviceClientFactory, responseBuilder } = handlerInput;
    const {deviceId} = requestEnvelope.context.System.device;
    const upsServiceClient = serviceClientFactory.getUpsServiceClient();
    const timeZone = await upsServiceClient.getSystemTimeZone(deviceId);
    if (!timeZone) {
      return responseBuilder
                    .speak(NO_ACCESS)
                    .getResponse();
    }
    const speechResponse = `Tu zona horaria es ${timeZone}`;
    return responseBuilder
                    .speak(speechResponse)
                    .reprompt('¿Quieres alguna otra información?')
                    .getResponse();
  }
}

const TemperatureUnitIntentHandler = {
  canHandle(handlerInput) {
    return handlerInput.requestEnvelope.request.type === 'IntentRequest'
      && handlerInput.requestEnvelope.request.intent.name === 'TemperatureUnitIntent';
  },
  async handle(handlerInput) {
    const { requestEnvelope, serviceClientFactory, responseBuilder } = handlerInput;
    const {deviceId} = requestEnvelope.context.System.device;
    const upsServiceClient = serviceClientFactory.getUpsServiceClient();
    const temperatureUnit = await upsServiceClient.getSystemTemperatureUnit(deviceId);
    if (!temperatureUnit) {
      return responseBuilder
                    .speak(NO_ACCESS)
                    .getResponse();
    }
    const speechResponse = `Tu unidad de temperatura es ${temperatureUnit}`;
    return responseBuilder
                    .speak(speechResponse)
                    .reprompt('¿Quieres alguna otra información?')
                    .getResponse();
  }
}

const DistanceUnitIntentHandler = {
  canHandle(handlerInput) {
    return handlerInput.requestEnvelope.request.type === 'IntentRequest'
      && handlerInput.requestEnvelope.request.intent.name === 'DistanceUnitIntent';
  },
  async handle(handlerInput) {
    const { requestEnvelope, serviceClientFactory, responseBuilder } = handlerInput;
    const {deviceId} = requestEnvelope.context.System.device;
    const upsServiceClient = serviceClientFactory.getUpsServiceClient();
    const distanceUnit = await upsServiceClient.getSystemDistanceUnits(deviceId);
    if (!distanceUnit) {
      return responseBuilder
                    .speak(NO_ACCESS)
                    .getResponse();
    }
    const speechResponse = `Tu unidad de distancia es ${distanceUnit}`;
    return responseBuilder
                    .speak(speechResponse)
                    .reprompt('¿Quieres alguna otra información?')
                    .getResponse();
  }
}

const HelpHandler = {
  canHandle(handlerInput) {
    const request = handlerInput.requestEnvelope.request;
    return request.type === 'IntentRequest'
      && request.intent.name === 'AMAZON.HelpIntent';
  },
  handle(handlerInput) {
    return handlerInput.responseBuilder
      .speak(HELP_MESSAGE)
      .reprompt(HELP_REPROMPT)
      .getResponse();
  },
};

const ExitHandler = {
  canHandle(handlerInput) {
    const request = handlerInput.requestEnvelope.request;
    return request.type === 'IntentRequest'
      && (request.intent.name === 'AMAZON.CancelIntent'
        || request.intent.name === 'AMAZON.StopIntent');
  },
  handle(handlerInput) {
    return handlerInput.responseBuilder
      .speak(STOP_MESSAGE)
      .getResponse();
  },
};

const SessionEndedRequestHandler = {
  canHandle(handlerInput) {
    const request = handlerInput.requestEnvelope.request;
    return request.type === 'SessionEndedRequest';
  },
  handle(handlerInput) {
    console.log(`Session ended with reason: ${handlerInput.requestEnvelope.request.reason}`);
    return handlerInput.responseBuilder.getResponse();
  },
};

const ServiceErrorHandler = {
  canHandle(handlerInput, error) {
    return error.name === 'ServiceError';
  },
  handle(handlerInput, error) {
    if (error.statusCode === 403) {
      return handlerInput.responseBuilder
        .speak(NOTIFY_MISSING_PERMISSIONS)
        .withAskForPermissionsConsentCard(ADDRESS_PERMISSION)
        .getResponse();
    }
    return handlerInput.responseBuilder
      .speak(LOCATION_FAILURE)
      .getResponse();
  },
};

const SimulatorErrorHandler = {
  canHandle(handlerInput, error) {
    return error.message.includes('Failed trying to parse the response body');
  },
  handle(handlerInput, error) {
    return handlerInput.responseBuilder
      .speak(SIMULATOR_FAILURE)
      .getResponse();
  }
};

const ErrorHandler = {
  canHandle() {
    return true;
  },
  handle(handlerInput, error) {
    console.log(`ERROR handler: ${error.message}`);
    return handlerInput.responseBuilder
      .speak(ERROR_MESSAGE)
      .getResponse();
  },
};

const HELP_MESSAGE = 'Puedes preguntarme por tu dirección, tu email, tu nombre, tu número de móvil, tu unidad de temperatura, tu unidad de distancia y tu zona horaria.';
const HELP_REPROMPT = '¿Cómo te puedo ayudar?';
const STOP_MESSAGE = '¡Adiós!';
const ERROR_MESSAGE = 'Perdona, ha ocurrido un error.';
const NOTIFY_MISSING_PERMISSIONS = 'Por favor habilita los permisos solicitados en tu app Alexa y vuelve a intentarlo.';
const NO_INFO = 'Parece que no lo tienes configurado. Ingresalo en la app Alexa y vuelve a intentarlo.';
const NO_ACCESS = 'Parece que no he podido recuperar el dato. Vuelve a intentarlo.';
const ADDRESS_AVAILABLE = 'Aquí tienes tu dirección: ';
const LOCATION_FAILURE = 'Ha habido un error accediendo la API para obtener la dirección. Por favor intenta otra vez.';
const SIMULATOR_FAILURE = 'Debes usar esta skill desde un dispositivo real, no desde el simulador. Por favor intenta otra vez.';
// no olvides habilitar estos permisos en la configuración de la skill en developer.amazon.com/alexa
const ADDRESS_PERMISSION = ['read::alexa:device:all:address'];
const FULL_NAME_PERMISSION = ['alexa::profile:name:read'];
const GIVEN_NAME_PERMISSION = ['alexa::profile:given_name:read'];
const EMAIL_PERMISSION = ['alexa::profile:email:read'];
const MOBILE_PERMISSION = ['alexa::profile:mobile_number:read'];

const skillBuilder = Alexa.SkillBuilders.custom();

exports.handler = skillBuilder
  .addRequestHandlers(
    LaunchHandler,
    AddressIntentHandler,
    EmailIntentHandler,
    MobileIntentHandler,
    NameIntentHandler,
    TimeZoneIntentHandler,
    TemperatureUnitIntentHandler,
    DistanceUnitIntentHandler,
    HelpHandler,
    ExitHandler,
    SessionEndedRequestHandler
  )
  .addErrorHandlers(SimulatorErrorHandler)
  .addErrorHandlers(ServiceErrorHandler)
  .addErrorHandlers(ErrorHandler)
  .withApiClient(new Alexa.DefaultApiClient())
  .lambda();

skill.json

{
  "manifest": {
    "publishingInformation": {
      "locales": {
        "es-ES": {
          "name": "datos personales"
        }
      }
    },
    "apis": {
      "custom": {
        "endpoint": {
          "sourceDir": "lambda/custom"
        }
      }
    },
    "manifestVersion": "1.0",
    "permissions": [
      {
        "name": "alexa::devices:all:address:full:read"
      },
      {
        "name": "alexa::profile:email:read"
      },
      {
        "name": "alexa::profile:mobile_number:read"
      },
      {
        "name": "alexa::profile:name:read"
      }
    ]
  }
}