Exemplo n.º 1
0
def handle_power_state(request):
    # Note: This sample always returns a success response for either a request to TurnOff or TurnOn
    # TODO: handle other scenarios, other than on/off?
    endpoint_id = request['directive']['endpoint']['endpointId']
    name = name = request['directive']['header']['name']
    power_state_value = 'ON' if name == 'TurnOn' else 'OFF'
    correlation_token = request['directive']['header'][
        'correlationToken']  # required in the response
    bearer_token = request['directive']['endpoint']['scope'][
        'token']  # identifies the user

    intof_id = umap.token_intof_map(bearer_token)
    if (intof_id == None):
        response = get_error_response('INTERNAL_ERROR',
                                      'Unable to get the Intof user id.')
        return send_response(response.get())

    # TODO: Check for device error in setting the state
    state_set = set_device_state(intof_id, endpoint_id, power_state_value)
    if (state_set == False):
        print('-   Error setting the device state!')
        response = get_error_response(
            'ENDPOINT_UNREACHABLE', 'The device is not responding.'
        )  # TODO: use friendly name in the response
        return send_response(response.get())
    response = AlexaResponse(correlation_token=correlation_token)
    response.add_context_property(namespace='Alexa.PowerController',
                                  name='powerState',
                                  value=power_state_value)
    return response
def handle_control(name, event):
    endpoint_id = event['directive']['endpoint']['endpointId']
    power_state_value = 'OFF' if name == 'TurnOff' else 'ON'
    correlation_token = event['directive']['header']['correlationToken']

    state_sent = send_device_state(endpoint_id=endpoint_id,
                                   state='powerState',
                                   value=power_state_value)
    if not state_sent:
        return AlexaResponse(name='ErrorResponse',
                             payload={
                                 'type': 'ENDPOINT_UNREACHABLE',
                                 'message': 'Unable to reach endpoint.'
                             }).get()

    state_save = save_device_state(endpoint_id=endpoint_id,
                                   state='powerState',
                                   value=power_state_value)
    if not state_save:
        return AlexaResponse(name='ErrorResponse',
                             payload={
                                 'type': 'ENDPOINT_UNREACHABLE',
                                 'message': 'Unable to reach dynamo.'
                             }).get()

    apcr = AlexaResponse(correlation_token=correlation_token)
    apcr.add_context_property(namespace=NAMESPACE_CONTROL,
                              name='powerState',
                              value=power_state_value,
                              endpoint_id=endpoint_id)
    return apcr.get()
Exemplo n.º 3
0
def control_device(request):
    """
    Control a specific device
    """
    power_state_value = 'OFF' if request['directive']['header'][
        'name'] == 'TurnOff' else 'ON'
    endpoint_id = request['directive']['endpoint']['endpointId']
    correlation_token = request['directive']['header']['correlationToken']

    # Check for an error when setting the state
    state_set = set_device_state(endpoint_id=endpoint_id,
                                 value=power_state_value)
    if state_set is None:
        return error(type='ENDPOINT_UNREACHABLE',
                     message='Unable to reach endpoint database.')
    elif not state_set:
        return error(
            type='ENDPOINT_UNREACHABLE',
            message='I did not get a response from the device controller.')

    apcr = AlexaResponse(correlation_token=correlation_token)
    apcr.add_context_property(namespace='Alexa.PowerController',
                              name='powerState',
                              value=power_state_value)
    return success(apcr.get())
def handle_mode(name, event):
    endpoint_id = event['directive']['endpoint']['endpointId']
    correlation_token = event['directive']['header']['correlationToken']

    if name == "SetMode":
        mode = event['directive']['payload']['mode']
        if mode == 'LightMode.SingleColor':
            neo_mode = 1
        elif mode == 'LightMode.Knightrider':
            neo_mode = 2
        elif mode == 'LightMode.Starburst':
            neo_mode = 3
        elif mode == 'LightMode.SlowRainbow':
            neo_mode = 4
        elif mode == 'LightMode.FastRainbow':
            neo_mode = 5
        elif mode == 'LightMode.Emergency':
            neo_mode = 6

    elif name == "StateReport":
        mode = False

    if mode:
        state_sent = send_device_state(endpoint_id=endpoint_id,
                                       state='SetMode',
                                       value=neo_mode)
        if not state_sent:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type': 'ENDPOINT_UNREACHABLE',
                                     'message': 'Unable to reach endpoint.'
                                 }).get()

        state_save = save_device_state(endpoint_id=endpoint_id,
                                       state='SetMode',
                                       value=mode)
        if not state_save:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type': 'ENDPOINT_UNREACHABLE',
                                     'message': 'Unable to reach dynamo.'
                                 }).get()

    apcr = AlexaResponse(correlation_token=correlation_token)
    apcr.add_context_property(namespace=NAMESPACE_MODE,
                              name='mode',
                              value=mode,
                              endpoint_id=endpoint_id)
    return apcr.get()
def handle_color(name, event):
    endpoint_id = event['directive']['endpoint']['endpointId']
    correlation_token = event['directive']['header']['correlationToken']

    if name == "SetColor":
        color = event['directive']['payload']['color']
        neo_color = dict()
        neo_color["hue"] = round(color["hue"] * 65536 / 360)
        neo_color["saturation"] = round(color["saturation"] * 255)
        neo_color["brightness"] = round(color["brightness"] * 255)

    elif name == "StateReport":
        color = False

    if color:
        state_sent = send_device_state(endpoint_id=endpoint_id,
                                       state='SetColor',
                                       value=neo_color)
        if not state_sent:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type': 'ENDPOINT_UNREACHABLE',
                                     'message': 'Unable to reach endpoint.'
                                 }).get()

        state_save = save_device_state(endpoint_id=endpoint_id,
                                       state='SetColor',
                                       value=color)
        if not state_save:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type': 'ENDPOINT_UNREACHABLE',
                                     'message': 'Unable to reach dynamo.'
                                 }).get()

    apcr = AlexaResponse(correlation_token=correlation_token)
    apcr.add_context_property(namespace=NAMESPACE_COLOR,
                              name='color',
                              value=color,
                              endpoint_id=endpoint_id)
    return apcr.get()
def handle_brightness(name, event):
    endpoint_id = event['directive']['endpoint']['endpointId']
    correlation_token = event['directive']['header']['correlationToken']

    if name == "SetBrightness":
        brightness = event['directive']['payload']['brightness']
    elif name == "AdjustBrightness":
        brightness_delta = event['directive']['payload']['brightnessDelta']
        brightness = 50
    elif name == "StateReport":
        brightness = False

    if brightness:
        neo_brightness = round(brightness * 255 / 100)
        state_sent = send_device_state(endpoint_id=endpoint_id,
                                       state='SetBrightness',
                                       value=neo_brightness)
        if not state_sent:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type': 'ENDPOINT_UNREACHABLE',
                                     'message': 'Unable to reach endpoint.'
                                 }).get()

        state_save = save_device_state(endpoint_id=endpoint_id,
                                       state='SetBrightness',
                                       value=brightness)
        if not state_save:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type': 'ENDPOINT_UNREACHABLE',
                                     'message': 'Unable to reach dynamo.'
                                 }).get()

    apcr = AlexaResponse(correlation_token=correlation_token)
    apcr.add_context_property(namespace=NAMESPACE_BRIGHTNESS,
                              name='brightness',
                              value=brightness,
                              endpoint_id=endpoint_id)
    return apcr.get()
Exemplo n.º 7
0
    def process(self, request, client_id, client_secret, redirect_uri):
        print('LOG api_handler_directive.process -----')
        # print(json.dumps(request))

        response = None
        # Process an Alexa directive and route to the right namespace
        # Only process if there is an actual body to process otherwise return an ErrorResponse
        json_body = request['body']
        if json_body:
            json_object = json.loads(json_body)
            namespace = json_object['directive']['header']['namespace']

            if namespace == "Alexa":
                name = json_object['directive']['header']['name']
                correlation_token = json_object['directive']['header'][
                    'correlationToken']
                token = json_object['directive']['endpoint']['scope']['token']
                endpoint_id = json_object['directive']['endpoint'][
                    'endpointId']

                if name == 'ReportState':
                    # Get the User ID from the access_token
                    response_user_id = json.loads(
                        ApiAuth.get_user_id(token).read().decode('utf-8'))
                    result = dynamodb_aws.get_item(
                        TableName='SampleEndpointDetails',
                        Key={'EndpointId': {
                            'S': endpoint_id
                        }})
                    capabilities_string = self.get_db_value(
                        result['Item']['Capabilities'])
                    capabilities = json.loads(capabilities_string)
                    props = []
                    for c in capabilities:
                        if not 'properties' in c:
                            continue
                        retrievable = c['properties'].get('retrievable', False)
                        if retrievable:
                            props.append(c)
                    state = {}
                    try:
                        res = iot_data_aws.get_thing_shadow(
                            thingName=endpoint_id)
                        shadow = json.loads(res['payload'].read())
                        state = shadow['state']['desired']
                    except ClientError as e:
                        print('LOG ', e)

                    print('Sending StateReport for', response_user_id,
                          'on endpoint', endpoint_id)
                    statereport_response = AlexaResponse(
                        name='StateReport',
                        endpoint_id=endpoint_id,
                        correlation_token=correlation_token,
                        token=token)

                    for p in props:
                        key = p['properties']['supported'][0]['name']
                        if 'instance' in p:
                            key = p['instance'] + '.' + key
                        current_state = state.get(key,
                                                  DEFAULT_VAL[p['interface']])
                        if 'instance' in p:
                            statereport_response.add_context_property(
                                namespace=p['interface'],
                                name=p['properties']['supported'][0]['name'],
                                value=current_state,
                                instance=p['instance'])
                        else:
                            statereport_response.add_context_property(
                                namespace=p['interface'],
                                name=p['properties']['supported'][0]['name'],
                                value=current_state)

                    response = statereport_response.get()

            if namespace == "Alexa.Authorization":
                grant_code = json_object['directive']['payload']['grant'][
                    'code']
                grantee_token = json_object['directive']['payload']['grantee'][
                    'token']

                # Spot the default from the Alexa.Discovery sample. Use as a default for development.
                if grantee_token == 'access-token-from-skill':
                    user_id = "0"  # <- Useful for development
                    response_object = {
                        'access_token': 'INVALID',
                        'refresh_token': 'INVALID',
                        'token_type': 'Bearer',
                        'expires_in': 9000
                    }
                else:
                    # Get the User ID
                    response_user_id = json.loads(
                        ApiAuth.get_user_id(grantee_token).read().decode(
                            'utf-8'))
                    if 'error' in response_user_id:
                        print(
                            'ERROR api_handler_directive.process.authorization.user_id:',
                            response_user_id['error_description'])
                        return AlexaResponse(name='ErrorResponse',
                                             payload={
                                                 'type': 'INTERNAL_ERROR',
                                                 'message': response_user_id
                                             })

                    user_id = response_user_id['user_id']
                    print(
                        'LOG api_handler_directive.process.authorization.user_id:',
                        user_id)

                # Get the Access and Refresh Tokens
                api_auth = ApiAuth()
                print('grant_code', grant_code, 'client_id', client_id,
                      'client_secret', client_secret, 'redirect_uri',
                      redirect_uri)
                response_token = api_auth.get_access_token(
                    grant_code, client_id, client_secret, redirect_uri)
                response_token_string = response_token.read().decode('utf-8')
                print(
                    'LOG api_handler_directive.process.authorization.response_token_string:',
                    response_token_string)
                response_object = json.loads(response_token_string)

                if 'error' in response_object:
                    return AlexaResponse(name='ErrorResponse',
                                         payload={
                                             'type': 'INTERNAL_ERROR',
                                             'response_object': response_object
                                         })

                # Store the retrieved from the Authorization Server
                access_token = response_object['access_token']
                refresh_token = response_object['refresh_token']
                token_type = response_object['token_type']
                expires_in = response_object['expires_in']

                # Calculate expiration
                expiration_utc = datetime.utcnow() + timedelta(
                    seconds=(int(expires_in) - 5))

                # Store the User Information - This is useful for inspection during development
                table = boto3.resource('dynamodb').Table('SampleUsers')
                result = table.put_item(
                    Item={
                        'UserId':
                        user_id,
                        'GrantCode':
                        grant_code,
                        'GranteeToken':
                        grantee_token,
                        'AccessToken':
                        access_token,
                        'ClientId':
                        client_id,
                        'ClientSecret':
                        client_secret,
                        'ExpirationUTC':
                        expiration_utc.strftime("%Y-%m-%dT%H:%M:%S.00Z"),
                        'RedirectUri':
                        redirect_uri,
                        'RefreshToken':
                        refresh_token,
                        'TokenType':
                        token_type
                    })

                if result['ResponseMetadata']['HTTPStatusCode'] == 200:
                    print(
                        'LOG api_handler_directive.process.authorization.SampleUsers.put_item:',
                        result)
                    alexa_accept_grant_response = AlexaResponse(
                        namespace='Alexa.Authorization',
                        name='AcceptGrant.Response')
                    response = alexa_accept_grant_response.get()
                else:
                    error_message = 'Error creating User'
                    print('ERR api_handler_directive.process.authorization',
                          error_message)
                    alexa_error_response = AlexaResponse(name='ErrorResponse')
                    alexa_error_response.set_payload({
                        'type': 'INTERNAL_ERROR',
                        'message': error_message
                    })
                    response = alexa_error_response.get()

            if namespace == "Alexa.Cooking":
                name = json_object['directive']['header']['name']
                correlation_token = json_object['directive']['header'][
                    'correlationToken']
                token = json_object['directive']['endpoint']['scope']['token']
                endpoint_id = json_object['directive']['endpoint'][
                    'endpointId']
                if name == "SetCookingMode":
                    alexa_error_response = AlexaResponse(
                        endpoint_id=endpoint_id,
                        correlation_token=correlation_token,
                        token=token)
                    response = alexa_error_response.get()

            if namespace == "Alexa.Discovery":
                # Given the Access Token, get the User ID
                access_token = json_object['directive']['payload']['scope'][
                    'token']

                # Spot the default from the Alexa.Discovery sample. Use as a default for development.
                if access_token == 'access-token-from-skill':
                    print(
                        'WARN api_handler_directive.process.discovery.user_id: Using development user_id of 0'
                    )
                    user_id = "0"  # <- Useful for development
                else:
                    response_user_id = json.loads(
                        ApiAuth.get_user_id(access_token).read().decode(
                            'utf-8'))
                    if 'error' in response_user_id:
                        print(
                            'ERROR api_handler_directive.process.discovery.user_id: '
                            + response_user_id['error_description'])
                    user_id = response_user_id['user_id']
                    print(
                        'LOG api_handler_directive.process.discovery.user_id:',
                        user_id)

                adr = AlexaResponse(namespace='Alexa.Discovery',
                                    name='Discover.Response')

                # Get the list of endpoints to return for a User ID and add them to the response
                # Use the AWS IoT entries for state but get the discovery details from DynamoDB
                # Wanted to list by group name but that requires a second lookup for the details
                # iot_aws.list_things_in_thing_group(thingGroupName="Samples")
                list_response = iot_aws.list_things()

                # Get a list of sample things by the user_id attribute
                for thing in list_response['things']:
                    if 'user_id' in thing['attributes']:
                        if thing['attributes']['user_id'] == user_id:
                            # We have an endpoint thing!
                            endpoint_details = ApiHandlerEndpoint.EndpointDetails(
                            )
                            endpoint_details.id = str(thing['thingName'])
                            print(
                                'LOG api_handler_directive.process.discovery: Found:',
                                endpoint_details.id, 'for user:'******'SampleEndpointDetails',
                                Key={'EndpointId': {
                                    'S': endpoint_details.id
                                }})
                            capabilities_string = self.get_db_value(
                                result['Item']['Capabilities'])
                            endpoint_details.capabilities = json.loads(
                                capabilities_string)
                            endpoint_details.description = self.get_db_value(
                                result['Item']['Description'])
                            endpoint_details.display_categories = json.loads(
                                self.get_db_value(
                                    result['Item']['DisplayCategories']))
                            endpoint_details.friendly_name = self.get_db_value(
                                result['Item']['FriendlyName'])
                            endpoint_details.manufacturer_name = self.get_db_value(
                                result['Item']['ManufacturerName'])
                            endpoint_details.sku = self.get_db_value(
                                result['Item']['SKU'])
                            endpoint_details.user_id = self.get_db_value(
                                result['Item']['UserId'])

                            adr.add_payload_endpoint(
                                friendly_name=endpoint_details.friendly_name,
                                endpoint_id=endpoint_details.id,
                                capabilities=endpoint_details.capabilities,
                                display_categories=endpoint_details.
                                display_categories,
                                manufacturer_name=endpoint_details.
                                manufacturer_name)

                response = adr.get()

            if namespace == "Alexa.PowerController":
                name = json_object['directive']['header']['name']
                correlation_token = None
                if 'correlationToken' in json_object['directive']['header']:
                    correlation_token = json_object['directive']['header'][
                        'correlationToken']
                token = json_object['directive']['endpoint']['scope']['token']
                endpoint_id = json_object['directive']['endpoint'][
                    'endpointId']

                response_user_id = json.loads(
                    ApiAuth.get_user_id(token).read().decode('utf-8'))
                if 'error' in response_user_id:
                    print(
                        'ERROR api_handler_directive.process.power_controller.user_id: '
                        + response_user_id['error_description'])
                user_id = response_user_id['user_id']
                print(
                    'LOG api_handler_directive.process.power_controller.user_id:',
                    user_id)

                # Convert to a local stored state
                power_state_value = 'OFF' if name == "TurnOff" else 'ON'
                msg = {'state': {'desired': {'powerState': 'ON'}}}

                msg['state']['desired']['powerState'] = power_state_value
                mqtt_msg = json.dumps(msg)
                # Send the state to the Thing Shadow
                try:
                    response_update = iot_data_aws.update_thing_shadow(
                        thingName=endpoint_id, payload=mqtt_msg.encode())
                    print(
                        'LOG api_handler_directive.process.power_controller.response_update -----'
                    )
                    print(response_update)
                    alexa_response = AlexaResponse(
                        token=token,
                        correlation_token=correlation_token,
                        endpoint_id=endpoint_id)
                    alexa_response.add_context_property(
                        namespace='Alexa.PowerController',
                        name='powerState',
                        value=power_state_value)
                    alexa_response.add_context_property()
                    response = alexa_response.get()

                except ClientError as e:
                    print(
                        'ERR api_handler_directive.process.power_controller Exception:ClientError:',
                        e)
                    response = AlexaResponse(name='ErrorResponse',
                                             message=e).get()

            if namespace == "Alexa.ModeController":
                alexa_error_response = AlexaResponse(name='ErrorResponse')
                alexa_error_response.set_payload({
                    'type':
                    'INTERNAL_ERROR',
                    'message':
                    'Not Yet Implemented'
                })
                response = alexa_error_response.get()

            if namespace == "Alexa.RangeController":
                name = json_object['directive']['header']['name']
                correlation_token = json_object['directive']['header'][
                    'correlationToken']
                instance = json_object['directive']['header']['instance']
                token = json_object['directive']['endpoint']['scope']['token']
                endpoint_id = json_object['directive']['endpoint'][
                    'endpointId']

                result = dynamodb_aws.get_item(
                    TableName='SampleEndpointDetails',
                    Key={'EndpointId': {
                        'S': endpoint_id
                    }})
                capabilities_string = self.get_db_value(
                    result['Item']['Capabilities'])
                capabilities = json.loads(capabilities_string)

                for c in capabilities:
                    if 'instance' in c and c['instance'] == instance:
                        MIN_VAL = c['configuration']['supportedRange'][
                            'minimumValue']
                        MAX_VAL = c['configuration']['supportedRange'][
                            'maximumValue']
                        PREC = c['configuration']['supportedRange'][
                            'precision']
                        break

                alexa_response = AlexaResponse(
                    endpoint_id=endpoint_id,
                    correlation_token=correlation_token,
                    token=token)
                value = 0
                if name == "AdjustRangeValue":
                    range_value_delta = json_object['directive']['payload'][
                        'rangeValueDelta']
                    range_value_delta_default = json_object['directive'][
                        'payload']['rangeValueDeltaDefault']
                    reported_range_value = 0

                    # Check to see if we need to use the delta default value (The user did not give a precision)
                    if range_value_delta_default:
                        range_value_delta = PREC

                    # Lookup the existing value of the endpoint by endpoint_id and limit ranges as appropriate - for this sample, expecting 1-6
                    try:
                        response = iot_data_aws.get_thing_shadow(
                            thingName=endpoint_id)
                        payload = json.loads(response['payload'].read())
                        reported_range_value = payload['state']['reported'][
                            instance + '.rangeValue']
                        print(
                            'LOG api_handler_directive.process.range_controller.range_value:',
                            reported_range_value)
                    except ClientError as e:
                        print(e)
                    except KeyError as errorKey:
                        print('Could not find key:', errorKey)

                    new_range_value = reported_range_value + range_value_delta

                    value = max(min(new_range_value, MAX_VAL), MIN_VAL)

                if name == "SetRangeValue":
                    range_value = json_object['directive']['payload'][
                        'rangeValue']

                    value = max(min(range_value, MAX_VAL), MIN_VAL)
                    alexa_response.add_context_property(
                        namespace='Alexa.RangeController',
                        name='rangeValue',
                        value=value)

                # Update the Thing Shadow
                msg = {'state': {'desired': {}}}
                # NOTE: The instance is used to keep the stored value unique
                msg['state']['desired'][instance + '.rangeValue'] = value
                mqtt_msg = json.dumps(msg)
                response_update = iot_data_aws.update_thing_shadow(
                    thingName=endpoint_id, payload=mqtt_msg.encode())
                print(
                    'LOG api_handler_directive.process.range_controller.response_update -----'
                )
                print(response_update)

                # Send back the response
                response = alexa_response.get()

            if namespace == "Alexa.ToggleController":
                name = json_object['directive']['header']['name']
                correlation_token = json_object['directive']['header'][
                    'correlationToken']
                instance = json_object['directive']['header']['instance']
                token = json_object['directive']['endpoint']['scope']['token']
                endpoint_id = json_object['directive']['endpoint'][
                    'endpointId']

                # Convert to a local stored state
                toggle_state_value = 'OFF' if name == "TurnOff" else 'ON'
                state_name = instance + '.state'
                msg = {'state': {'desired': {state_name: 'ON'}}}
                msg['state']['desired'][state_name] = toggle_state_value
                mqtt_msg = json.dumps(msg)
                # Send the state to the Thing Shadow
                try:
                    response_update = iot_data_aws.update_thing_shadow(
                        thingName=endpoint_id, payload=mqtt_msg.encode())
                    print(
                        'LOG api_handler_directive.process.toggle_controller.response_update -----'
                    )
                    print(response_update)
                    alexa_response = AlexaResponse(
                        token=token,
                        correlation_token=correlation_token,
                        endpoint_id=endpoint_id)
                    alexa_response.add_context_property(
                        namespace='Alexa.ToggleController',
                        name='toggleState',
                        instance=instance,
                        value=toggle_state_value)
                    alexa_response.add_context_property()
                    response = alexa_response.get()

                except ClientError as e:
                    print(
                        'ERR api_handler_directive.process.toggle_controller Exception:ClientError:',
                        e)
                    response = AlexaResponse(name='ErrorResponse',
                                             message=e).get()

        else:
            alexa_error_response = AlexaResponse(name='ErrorResponse')
            alexa_error_response.set_payload({
                'type': 'INTERNAL_ERROR',
                'message': 'Empty Body'
            })
            response = alexa_error_response.get()

        if response is None:
            # response set to None indicates an unhandled directive, review the logs
            alexa_error_response = AlexaResponse(name='ErrorResponse')
            alexa_error_response.set_payload({
                'type':
                'INTERNAL_ERROR',
                'message':
                'Empty Response: No response processed. Unhandled Directive.'
            })
            response = alexa_error_response.get()

        print('LOG api_handler_directive.process.response -----')
        print(json.dumps(response))
        return response
Exemplo n.º 8
0
def lambda_handler(request, context):

    # Dump the request for logging - check the CloudWatch logs
    print('lambda_handler request  -----')
    print(json.dumps(request))

    if context is not None:
        print('lambda_handler context  -----')
        print(context)

    # Validate we have an Alexa directive
    if 'directive' not in request:
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={
                'type':
                'INVALID_DIRECTIVE',
                'message':
                'Missing key: directive, Is the request a valid Alexa Directive?'
            })
        return send_response(aer.get())

    # Check the payload version
    payload_version = request['directive']['header']['payloadVersion']
    if payload_version != '3':
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={
                'type': 'INTERNAL_ERROR',
                'message': 'This skill only supports Smart Home API version 3'
            })
        return send_response(aer.get())

    # Crack open the request and see what is being requested
    name = request['directive']['header']['name']
    namespace = request['directive']['header']['namespace']

    print('Name:' + name)
    print('Namespace:' + namespace)

    # Handle the incoming request from Alexa based on the namespace

    if namespace == 'Alexa.Authorization':

        if name == 'AcceptGrant':

            # Note: This sample accepts any grant request
            # In your implementation you would use the code and token to get and store access tokens
            grant_code = request['directive']['payload']['grant']['code']
            grantee_token = request['directive']['payload']['grantee']['token']
            aar = AlexaResponse(namespace='Alexa.Authorization',
                                name='AcceptGrant.Response')
            return send_response(aar.get())

    if namespace == 'Alexa.Discovery':

        if name == 'Discover':

            adr = AlexaResponse(namespace='Alexa.Discovery',
                                name='Discover.Response')

            capability_alexa = adr.create_payload_endpoint_capability()

            capability_alexa_powercontroller = adr.create_payload_endpoint_capability(
                interface='Alexa.PowerController',
                supported=[{
                    'name': 'powerState'
                }])

            capability_alexa_temperaturesensor = adr.create_payload_endpoint_capability(
                interface='Alexa.TemperatureSensor',
                supported=[{
                    'name': 'temperature'
                }],
                retrievable='true',
                proactively_reported='true',
            )

            capability_alexa_endpointhealth = adr.create_payload_endpoint_capability(
                interface='Alexa.EndpointHealth',
                supported=[{
                    'name': 'connectivity'
                }],
                proactively_reported='true',
                retrievable='true')

            #    adr.add_payload_endpoint(
            #        friendly_name='Termostato Sala',
            #        endpoint_id='temperaturesensor-001',
            #        description='Termostato Sala',
            #        display_categories=["TEMPERATURE_SENSOR"],
            #        manufacturer_name = 'myself manufacter',
            #        capabilities=[capability_alexa, capability_alexa_temperaturesensor, capability_alexa_endpointhealth ])

            #    adr.add_payload_endpoint(
            #        friendly_name='Termostato Cucina',
            #        endpoint_id='temperaturesensor-002',
            #        description='Termostato Cucina',
            #        display_categories=["TEMPERATURE_SENSOR"],
            #        manufacturer_name = 'myself manufacter',
            #        capabilities=[capability_alexa, capability_alexa_temperaturesensor, capability_alexa_endpointhealth ])

            adr.add_payload_endpoint(friendly_name='Luce 01',
                                     endpoint_id='light-001',
                                     description='Luce 01',
                                     display_categories=["LIGHT"],
                                     manufacturer_name='myself manufacter',
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])

            adr.add_payload_endpoint(friendly_name='Luce 02',
                                     endpoint_id='light-002',
                                     description='Luce 02',
                                     display_categories=["LIGHT"],
                                     manufacturer_name='myself manufacter',
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])

            adr.add_payload_endpoint(friendly_name='Luce 03',
                                     endpoint_id='light-003',
                                     description='Luce 03',
                                     display_categories=["LIGHT"],
                                     manufacturer_name='myself manufacter',
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])

            adr.add_payload_endpoint(friendly_name='Luce 04',
                                     endpoint_id='light-004',
                                     description='Luce 04',
                                     display_categories=["LIGHT"],
                                     manufacturer_name='myself manufacter',
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])

            adr.add_payload_endpoint(friendly_name='Luce 05',
                                     endpoint_id='light-005',
                                     description='Luce 05',
                                     display_categories=["LIGHT"],
                                     manufacturer_name='myself manufacter',
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])

            adr.add_payload_endpoint(friendly_name='Luce 06',
                                     endpoint_id='light-006',
                                     description='Luce 06',
                                     display_categories=["LIGHT"],
                                     manufacturer_name='myself manufacter',
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])

            adr.add_payload_endpoint(friendly_name='Luce 07',
                                     endpoint_id='light-007',
                                     description='Luce 07',
                                     display_categories=["LIGHT"],
                                     manufacturer_name='myself manufacter',
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])

            adr.add_payload_endpoint(friendly_name='Luce 08',
                                     endpoint_id='light-008',
                                     description='Luce 08',
                                     display_categories=["LIGHT"],
                                     manufacturer_name='myself manufacter',
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])

            adr.add_payload_endpoint(friendly_name='Cancellino',
                                     endpoint_id='gate-001',
                                     description='Cancellino',
                                     display_categories=["DOOR"],
                                     manufacturer_name='myself manufacter',
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])

            return send_response(adr.get())

    if namespace == 'Alexa':

        if name == 'ReportState':

            print('Richiesta tipo ReportState  -----')

            # Note: This sample always returns a success response for either a request to TurnOff or TurnOn
            endpoint_id = request['directive']['endpoint']['endpointId']

            print('ENDPOINT ID: ' + endpoint_id)

            correlation_token = request['directive']['header'][
                'correlationToken']
            token = request['directive']['endpoint']['scope']['token']

            print('Correlation_Token: ' + correlation_token)
            print('Token: ' + token)

            apcr = AlexaResponse(name='StateReport',
                                 endpoint_id=endpoint_id,
                                 correlation_token=correlation_token,
                                 token=token)

            if (endpoint_id == 'temperaturesensor-001'):

                apcr.add_context_property(namespace='Alexa.TemperatureSensor',
                                          name='temperature',
                                          value={
                                              'value': '19.9',
                                              'scale': 'CELSIUS'
                                          })

            elif (endpoint_id == 'temperaturesensor-002'):

                apcr.add_context_property(namespace='Alexa.TemperatureSensor',
                                          name='temperature',
                                          value={
                                              'value': '22.3',
                                              'scale': 'CELSIUS'
                                          })

            return send_response(apcr.get())

    if namespace == 'Alexa.PowerController' or namespace == 'Alexa.ToogleController':

        print('Richiesta tipo PowerController  -----')
        # Note: This sample always returns a success response for either a request to TurnOff or TurnOn
        endpoint_id = request['directive']['endpoint']['endpointId']

        power_state_value = 'OFF' if name == 'TurnOff' else 'ON'

        correlation_token = request['directive']['header']['correlationToken']

        # Check for an error when setting the state
        state_set = set_device_state(endpoint_id=endpoint_id,
                                     state='powerState',
                                     value=power_state_value)

        if not state_set:

            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type':
                                     'ENDPOINT_UNREACHABLE',
                                     'message':
                                     'Unable to reach endpoint database.'
                                 }).get()

        apcr = AlexaResponse(correlation_token=correlation_token)
        apcr.add_context_property(namespace='Alexa.PowerController',
                                  name='powerState',
                                  value=power_state_value)

        return send_response(apcr.get())
Exemplo n.º 9
0
def lambda_handler(request, context):

    # Dump the request for logging - check the CloudWatch logs
    print('lambda_handler request  -----')
    print(json.dumps(request))

    if context is not None:
        print('lambda_handler context  -----')
        print(context)

    # Validate we have an Alexa directive
    if 'directive' not in request:
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={'type': 'INVALID_DIRECTIVE',
                     'message': 'Missing key: directive, Is the request a valid Alexa Directive?'})
        return send_response(aer.get())

    # Check the payload version
    payload_version = request['directive']['header']['payloadVersion']
    if payload_version != '3':
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={'type': 'INTERNAL_ERROR',
                     'message': 'This skill only supports Smart Home API version 3'})
        return send_response(aer.get())

    # Crack open the request and see what is being requested
    name = request['directive']['header']['name']
    namespace = request['directive']['header']['namespace']

    # Handle the incoming request from Alexa based on the namespace

    if namespace == 'Alexa.Authorization':
        if name == 'AcceptGrant':
            # Note: This sample accepts any grant request
            # In your implementation you would use the code and token to get and store access tokens
            grant_code = request['directive']['payload']['grant']['code']
            grantee_token = request['directive']['payload']['grantee']['token']
            aar = AlexaResponse(namespace='Alexa.Authorization', name='AcceptGrant.Response')
            return send_response(aar.get())

    if namespace == 'Alexa.Discovery':
        if name == 'Discover':
            adr = AlexaResponse(namespace='Alexa.Discovery', name='Discover.Response')
            capability_alexa = adr.create_payload_endpoint_capability()
            capability_alexa_powercontroller = adr.create_payload_endpoint_capability(
                interface='Alexa.PowerController',
                supported=[{'name': 'powerState'}])
            adr.add_payload_endpoint(
                friendly_name='Sample Switch',
                endpoint_id='sample-switch-01',
                capabilities=[capability_alexa, capability_alexa_powercontroller])
            return send_response(adr.get())

    if namespace == 'Alexa.PowerController':
        # Note: This sample always returns a success response for either a request to TurnOff or TurnOn
        endpoint_id = request['directive']['endpoint']['endpointId']
        power_state_value = 'OFF' if name == 'TurnOff' else 'ON'
        correlation_token = request['directive']['header']['correlationToken']

        # Check for an error when setting the state
        state_set = set_device_state(endpoint_id=endpoint_id, state='powerState', value=power_state_value)
        if not state_set:
            return AlexaResponse(
                name='ErrorResponse',
                payload={'type': 'ENDPOINT_UNREACHABLE', 'message': 'Unable to reach endpoint database.'}).get()

        # Check for an error when setting TurnOn/TurnOff time
        if power_state_value == 'ON':
            TurnOn_set = set_device_time(endpoint_id=endpoint_id, state='TurnOnTime', value=get_seconds_timestamp())
            if not TurnOn_set:
                return AlexaResponse(
                    name='ErrorResponse',
                    payload={'type': 'ENDPOINT_UNREACHABLE', 'message': 'Unable to reach endpoint database.'}).get()
            global turned_on
            turned_on = get_seconds_timestamp()
            time.sleep(random.uniform(1.500,2.500))
            TurnOff_set = set_device_state(endpoint_id=endpoint_id, state='powerState', value='OFF')
            print("turnedoff")
            # if not TurnOff_set:
            #     return AlexaResponse(
            #         name='ErrorResponse',
            #         payload={'type': 'ENDPOINT_UNREACHABLE', 'message': 'Unable to reach endpoint database.'}).get()
        if power_state_value == 'OFF':
            TurnOff_set = set_device_time(endpoint_id=endpoint_id, state='TurnOffTime', value=get_seconds_timestamp())
            if not TurnOff_set:
                return AlexaResponse(
                    name='ErrorResponse',
                    payload={'type': 'ENDPOINT_UNREACHABLE', 'message': 'Unable to reach endpoint database.'}).get()
            global turned_off
            turned_off = get_seconds_timestamp()
            uptime_length = get_uptime_length(turned_on, turned_off)
            last_uptime_length = set_device_time(endpoint_id=endpoint_id, state='LastUptimeLength', value=uptime_length)
            if not last_uptime_length:
                return AlexaResponse(
                    name='ErrorResponse',
                    payload={'type': 'ENDPOINT_UNREACHABLE', 'message': 'Unable to reach endpoint database.'}).get()
            add_value_to_file(uptime_length)

        apcr = AlexaResponse(correlation_token=correlation_token)
        apcr.add_context_property(namespace='Alexa.PowerController', name='powerState', value=power_state_value)
        return send_response(apcr.get())
def lambda_handler(request, context):

    # Dump the request for logging - check the CloudWatch logs
    print('lambda_handler request  -----')
    print(json.dumps(request))

    if context is not None:
        print('lambda_handler context  -----')
        print(context)

    # Validate we have an Alexa directive
    if 'directive' not in request:
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={
                'type':
                'INVALID_DIRECTIVE',
                'message':
                'Missing key: directive, Is the request a valid Alexa Directive?'
            })
        return send_response(aer.get())

    # Check the payload version
    payload_version = request['directive']['header']['payloadVersion']
    if payload_version != '3':
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={
                'type': 'INTERNAL_ERROR',
                'message': 'This skill only supports Smart Home API version 3'
            })
        return send_response(aer.get())

    # Crack open the request and see what is being requested
    name = request['directive']['header']['name']
    namespace = request['directive']['header']['namespace']

    # Handle the incoming request from Alexa based on the namespace

    if namespace == 'Alexa.Authorization':
        if name == 'AcceptGrant':
            # Note: This sample accepts any grant request
            # In your implementation you would use the code and token to get and store access tokens
            grant_code = request['directive']['payload']['grant']['code']
            grantee_token = request['directive']['payload']['grantee']['token']
            aar = AlexaResponse(namespace='Alexa.Authorization',
                                name='AcceptGrant.Response')
            return send_response(aar.get())

    if namespace == 'Alexa.Discovery':
        if name == 'Discover':
            adr = AlexaResponse(namespace='Alexa.Discovery',
                                name='Discover.Response')
            capability_alexa = adr.create_payload_endpoint_capability()
            capability_alexa_powercontroller = adr.create_payload_endpoint_capability(
                interface='Alexa.PowerController',
                supported=[{
                    'name': 'powerState'
                }])
            adr.add_payload_endpoint(endpoint_id='LED',
                                     friendly_name='LED',
                                     description='これはただのLEDです。',
                                     display_categories=['LIGHT'],
                                     capabilities=[
                                         capability_alexa,
                                         capability_alexa_powercontroller
                                     ])
            return send_response(adr.get())

    if namespace == 'Alexa.PowerController':
        # Note: This sample always returns a success response for either a request to TurnOff or TurnOn
        endpoint_id = request['directive']['endpoint']['endpointId']
        power_state_value = 'OFF' if name == 'TurnOff' else 'ON'
        correlation_token = request['directive']['header']['correlationToken']

        apcr = AlexaResponse(correlation_token=correlation_token)
        apcr.add_context_property(namespace='Alexa.PowerController',
                                  name='powerState',
                                  value=power_state_value)

        # Update Thing Shadow Desired Value
        update_thing_shadow("led",
                            False if power_state_value == 'OFF' else True)

        return send_response(apcr.get())
def lambda_handler(request, context):
    # Dump the request for logging - check the CloudWatch logs
    print('lambda_handler request  -----')
    print(json.dumps(request))

    if context is not None:
        print('lambda_handler context  -----')
        print(context)

    # Validate we have an Alexa directive
    if 'directive' not in request:
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={
                'type':
                'INVALID_DIRECTIVE',
                'message':
                'Missing key: directive, Is the request a valid Alexa Directive?'
            })
        return send_response(aer.get())

    # Check the payload version
    payload_version = request['directive']['header']['payloadVersion']
    if payload_version != '3':
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={
                'type': 'INTERNAL_ERROR',
                'message': 'This skill only supports Smart Home API version 3'
            })
        return send_response(aer.get())

    # Crack open the request and see what is being requested
    name = request['directive']['header']['name']
    namespace = request['directive']['header']['namespace']

    # Handle the incoming request from Alexa based on the namespace

    if namespace == 'Alexa.Authorization':
        if name == 'AcceptGrant':
            # Note: This sample accepts any grant request
            # In your implementation you would use the code and token to get and store access tokens
            grant_code = request['directive']['payload']['grant']['code']
            grantee_token = request['directive']['payload']['grantee']['token']
            aar = AlexaResponse(namespace='Alexa.Authorization',
                                name='AcceptGrant.Response')
            return send_response(aar.get())

    if namespace == 'Alexa.Discovery':
        if name == 'Discover':
            adr = AlexaResponse(namespace='Alexa.Discovery',
                                name='Discover.Response')

            capability_alexa = adr.create_payload_endpoint_capability()

            capability_alexa_power_controller = adr.create_payload_endpoint_capability(
                interface='Alexa.PowerController',
                supported=[{
                    'name': 'powerState'
                }])
            capability_alexa_stepSpeaker_controller = adr.create_payload_endpoint_capability(
                interface='Alexa.StepSpeaker')
            capability_alexa_playback_controller = adr.create_payload_endpoint_capability(
                interface='Alexa.PlaybackController',
                supportedOperations=['Play', 'Pause', 'Stop'])

            adr.add_payload_endpoint(
                friendly_name='TV',
                endpoint_id='ps3-tv',
                manufacturer_name='Sony',
                description='PlayStation 3 TV connected with Raspberry Pi',
                displayCategories=['TV'],
                capabilities=[
                    capability_alexa, capability_alexa_power_controller,
                    capability_alexa_stepSpeaker_controller,
                    capability_alexa_playback_controller
                ])

            return send_response(adr.get())

    if namespace == 'Alexa.PowerController':
        # Note: This sample always returns a success response for either a request to TurnOff or TurnOn
        endpoint_id = request['directive']['endpoint']['endpointId']
        power_state_value = 'OFF' if name == 'TurnOff' else 'ON'
        correlation_token = request['directive']['header']['correlationToken']

        try:
            response = requests.post('{}toggle-power'.format(constants.url),
                                     json={'powerState': power_state_value})

            if response.status_code == 200:
                speech = response.text
            else:
                return AlexaResponse(
                    name='ErrorResponse',
                    payload={
                        'type': 'INTERNAL_ERROR',
                        'message': 'There was an error with the endpoint.'
                    }).get()
        except:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type': 'ENDPOINT_UNREACHABLE',
                                     'message': 'Unable to reach endpoint.'
                                 }).get()

        apcr = AlexaResponse(correlation_token=correlation_token)
        apcr.add_context_property(namespace='Alexa.PowerController',
                                  name='powerState',
                                  value=power_state_value)
    elif namespace == 'Alexa.StepSpeaker':
        endpoint_id = request['directive']['endpoint']['endpointId']
        correlation_token = request['directive']['header']['correlationToken']

        try:
            if name == 'AdjustVolume':
                response = requests.post(
                    '{}adjust-volume'.format(constants.url),
                    json={
                        'volumeSteps':
                        request['directive']['payload']['volumeSteps']
                    })
            else:
                response = None

            if response and response.status_code == 200:
                speech = response.text
            else:
                return AlexaResponse(
                    name='ErrorResponse',
                    payload={
                        'type': 'INTERNAL_ERROR',
                        'message': 'There was an error with the endpoint.'
                    }).get()
        except:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type': 'ENDPOINT_UNREACHABLE',
                                     'message': 'Unable to reach endpoint.'
                                 }).get()

        apcr = AlexaResponse(correlation_token=correlation_token)
        apcr.add_context_property(
            namespace='Alexa.StepSpeaker',
            name='volumeSteps',
            value=request['directive']['payload']['volumeSteps'])
    elif namespace == 'Alexa.PlaybackController':
        endpoint_id = request['directive']['endpoint']['endpointId']
        correlation_token = request['directive']['header']['correlationToken']

        try:
            if name == 'Play' or name == 'Pause' or name == 'Stop':
                response = requests.post(
                    '{}play-pause-stop-chromecast-youtube'.format(
                        constants.url),
                    json={'action': name})
            else:
                response = None

            if response and response.status_code == 200:
                speech = response.text
            else:
                return AlexaResponse(
                    name='ErrorResponse',
                    payload={
                        'type': 'INTERNAL_ERROR',
                        'message': 'There was an error with the endpoint.'
                    }).get()
        except:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type': 'ENDPOINT_UNREACHABLE',
                                     'message': 'Unable to reach endpoint.'
                                 }).get()

        apcr = AlexaResponse(correlation_token=correlation_token)
        apcr.add_context_property(namespace='Alexa.PlaybackController',
                                  name='action',
                                  value=name)

    return send_response(apcr.get())
Exemplo n.º 12
0
def lambda_handler(request, context):

    # Dump the request for logging - check the CloudWatch logs
    logger.debug('lambda_handler request  -----')
    logger.debug(json.dumps(request))

    if context is not None:
        logger.debug('lambda_handler context  -----')
        logger.debug(context)

    # Validate we have an Alexa directive
    if 'directive' not in request:
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={
                'type':
                'INVALID_DIRECTIVE',
                'message':
                'Missing key: directive, Is the request a valid Alexa Directive?'
            })
        return send_response(aer.get())

    # Check the payload version
    payload_version = request['directive']['header']['payloadVersion']
    if payload_version != '3':
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={
                'type': 'INTERNAL_ERROR',
                'message': 'This skill only supports Smart Home API version 3'
            })
        return send_response(aer.get())

    # Crack open the request and see what is being requested
    name = request['directive']['header']['name']
    namespace = request['directive']['header']['namespace']

    # Handle the incoming request from Alexa based on the namespace

    if namespace == 'Alexa.Authorization':
        if name == 'AcceptGrant':
            # Note: This sample accepts any grant request
            # In your implementation you would use the code and token to get and store access tokens
            grant_code = request['directive']['payload']['grant']['code']
            grantee_token = request['directive']['payload']['grantee']['token']
            aar = AlexaResponse(namespace='Alexa.Authorization',
                                name='AcceptGrant.Response')
            return send_response(aar.get())

    if namespace == 'Alexa.Discovery':
        if name == 'Discover':
            adr = AlexaResponse(namespace='Alexa.Discovery',
                                name='Discover.Response')
            capability_alexa = adr.create_payload_endpoint_capability()
            capability_alexa_powercontroller = adr.create_payload_endpoint_capability(
                interface='Alexa.PowerController',
                supported=[{
                    'name': 'powerState'
                }],
                proactively_reported=False,
                retrievable=False)
            capability_alexa_colorcontroller = adr.create_payload_endpoint_capability(
                interface='Alexa.ColorController',
                supported=[{
                    'name': 'color'
                }],
                proactively_reported=False,
                retrievable=False)
            adr.add_payload_endpoint(
                friendly_name=
                'Den Lights',  # TODO remove hardcoded friendly name
                endpoint_id=
                'thomas-den-lights',  # TODO removed hardcoded endpoint_id
                capabilities=[
                    capability_alexa, capability_alexa_powercontroller,
                    capability_alexa_colorcontroller
                ])
            return send_response(adr.get())

    if namespace == 'Alexa.PowerController':
        # Note: This sample always returns a success response for either a request to TurnOff or TurnOn
        endpoint_id = request['directive']['endpoint']['endpointId']
        power_state_value = 'OFF' if name == 'TurnOff' else 'ON'
        correlation_token = request['directive']['header']['correlationToken']

        # Check for an error when setting the state
        state_set = set_device_state(endpoint_id=endpoint_id,
                                     state='powerState',
                                     value=power_state_value)
        if not state_set:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type':
                                     'ENDPOINT_UNREACHABLE',
                                     'message':
                                     'Unable to reach endpoint database.'
                                 }).get()

        apcr = AlexaResponse(correlation_token=correlation_token)
        apcr.add_context_property(namespace='Alexa.PowerController',
                                  name='powerState',
                                  value=power_state_value)
        return send_response(apcr.get())

    if namespace == 'Alexa.ColorController' and name == 'SetColor':
        # Note: This sample always returns a success response for either a request to TurnOff or TurnOn
        endpoint_id = request['directive']['endpoint']['endpointId']
        correlation_token = request['directive']['header']['correlationToken']

        # Check for an error when setting the state
        color_set = set_color_state(
            endpoint_id=endpoint_id,
            state='color',
            value=request['directive']['payload']['color'])
        if not color_set:
            return AlexaResponse(name='ErrorResponse',
                                 payload={
                                     'type':
                                     'ENDPOINT_UNREACHABLE',
                                     'message':
                                     'Unable to reach endpoint database.'
                                 }).get()

        apcr = AlexaResponse(correlation_token=correlation_token)
        apcr.add_context_property(
            namespace='Alexa.ColorController',
            name='color',
            value=request['directive']['payload']['color'])
        return send_response(apcr.get())
Exemplo n.º 13
0
    def process(self, request, client_id, client_secret):
        print('LOG api_handler_directive.process -----')
        # print(json.dumps(request))

        response = None
        # Process an Alexa directive and route to the right namespace
        # Only process if there is an actual body to process otherwise return an ErrorResponse
        json_body = request['body']
        if json_body:
            json_object = json.loads(json_body)
            namespace = json_object['directive']['header']['namespace']

            if namespace == "Alexa":
                name = json_object['directive']['header']['name']
                correlation_token = json_object['directive']['header'][
                    'correlationToken']
                token = json_object['directive']['endpoint']['scope']['token']
                endpoint_id = json_object['directive']['endpoint'][
                    'endpointId']

                if name == 'ReportState':
                    # Get the User ID from the access_token
                    response_user_id = json.loads(
                        ApiAuth.get_user_id(token).read().decode('utf-8'))
                    result = dynamodb_aws.get_item(
                        TableName='APISensorEndpointDetails',
                        Key={'EndpointId': {
                            'S': endpoint_id
                        }})
                    capabilities_string = self.get_db_value(
                        result['Item']['Capabilities'])
                    capabilities = json.loads(capabilities_string)
                    props = []
                    for c in capabilities:
                        if not 'properties' in c:
                            continue
                        retrievable = c['properties'].get('retrievable', False)
                        if retrievable:
                            props.append(c)

                    print('Sending StateReport for', response_user_id,
                          'on endpoint', endpoint_id)
                    statereport_response = AlexaResponse(
                        name='StateReport',
                        endpoint_id=endpoint_id,
                        correlation_token=correlation_token,
                        token=token)

                    for p in props:
                        statereport_response.add_context_property(
                            namespace=p['interface'],
                            name=p['properties']['supported'][0]['name'],
                            value=DEFAULT_VAL[p['interface']])

                    response = statereport_response.get()

            if namespace == "Alexa.Authorization":
                grant_code = json_object['directive']['payload']['grant'][
                    'code']
                grantee_token = json_object['directive']['payload']['grantee'][
                    'token']

                # Spot the default from the Alexa.Discovery sample. Use as a default for development.
                if grantee_token == 'access-token-from-skill':
                    user_id = "0"  # <- Useful for development
                    response_object = {
                        'access_token': 'INVALID',
                        'refresh_token': 'INVALID',
                        'token_type': 'Bearer',
                        'expires_in': 9000
                    }
                else:
                    # Get the User ID
                    response_user_id = json.loads(
                        ApiAuth.get_user_id(grantee_token).read().decode(
                            'utf-8'))
                    if 'error' in response_user_id:
                        print(
                            'ERROR api_handler_directive.process.authorization.user_id:',
                            response_user_id['error_description'])
                        return AlexaResponse(name='ErrorResponse',
                                             payload={
                                                 'type': 'INTERNAL_ERROR',
                                                 'message': response_user_id
                                             })

                    user_id = response_user_id['user_id']
                    print(
                        'LOG api_handler_directive.process.authorization.user_id:',
                        user_id)

                # Get the Access and Refresh Tokens
                api_auth = ApiAuth()
                print('grant_code', grant_code, 'client_id', client_id,
                      'client_secret', client_secret)
                response_token = api_auth.get_access_token(
                    grant_code, client_id, client_secret)
                response_token_string = response_token.read().decode('utf-8')
                print(
                    'LOG api_handler_directive.process.authorization.response_token_string:',
                    response_token_string)
                response_object = json.loads(response_token_string)

                if 'error' in response_object:
                    return AlexaResponse(name='ErrorResponse',
                                         payload={
                                             'type': 'INTERNAL_ERROR',
                                             'response_object': response_object
                                         })

                # Store the retrieved from the Authorization Server
                access_token = response_object['access_token']
                refresh_token = response_object['refresh_token']
                token_type = response_object['token_type']
                expires_in = response_object['expires_in']

                # Calculate expiration
                expiration_utc = datetime.utcnow() + timedelta(
                    seconds=(int(expires_in) - 5))

                # Store the User Information - This is useful for inspection during development
                table = boto3.resource('dynamodb').Table('APISensorUsers')
                result = table.put_item(
                    Item={
                        'UserId':
                        user_id,
                        'GrantCode':
                        grant_code,
                        'GranteeToken':
                        grantee_token,
                        'AccessToken':
                        access_token,
                        'ClientId':
                        client_id,
                        'ClientSecret':
                        client_secret,
                        'ExpirationUTC':
                        expiration_utc.strftime("%Y-%m-%dT%H:%M:%S.00Z"),
                        'RefreshToken':
                        refresh_token,
                        'TokenType':
                        token_type
                    })

                if result['ResponseMetadata']['HTTPStatusCode'] == 200:
                    print(
                        'LOG api_handler_directive.process.authorization.SampleUsers.put_item:',
                        result)
                    alexa_accept_grant_response = AlexaResponse(
                        namespace='Alexa.Authorization',
                        name='AcceptGrant.Response')
                    response = alexa_accept_grant_response.get()
                else:
                    error_message = 'Error creating User'
                    print('ERR api_handler_directive.process.authorization',
                          error_message)
                    alexa_error_response = AlexaResponse(name='ErrorResponse')
                    alexa_error_response.set_payload({
                        'type': 'INTERNAL_ERROR',
                        'message': error_message
                    })
                    response = alexa_error_response.get()

            if namespace == "Alexa.Discovery":
                # Given the Access Token, get the User ID
                access_token = json_object['directive']['payload']['scope'][
                    'token']

                # Spot the default from the Alexa.Discovery sample. Use as a default for development.
                if access_token == 'access-token-from-skill':
                    print(
                        'WARN api_handler_directive.process.discovery.user_id: Using development user_id of 0'
                    )
                    user_id = "0"  # <- Useful for development
                else:
                    response_user_id = json.loads(
                        ApiAuth.get_user_id(access_token).read().decode(
                            'utf-8'))
                    if 'error' in response_user_id:
                        print(
                            'ERROR api_handler_directive.process.discovery.user_id: '
                            + response_user_id['error_description'])
                    user_id = response_user_id['user_id']
                    print(
                        'LOG api_handler_directive.process.discovery.user_id:',
                        user_id)

                adr = AlexaResponse(namespace='Alexa.Discovery',
                                    name='Discover.Response')

                # Get the list of endpoints associated with the user
                table = boto3.resource('dynamodb').Table(
                    'APISensorEndpointDetails')
                result = table.scan(FilterExpression=boto3.dynamodb.conditions.
                                    Attr('UserId').eq(user_id))

                for endpoint_details in result['Items']:

                    # We have an endpoint
                    print(
                        'LOG api_handler_directive.process.discovery: Found:',
                        endpoint_details['EndpointId'], 'for user:'******'FriendlyName'],
                        endpoint_id=endpoint_details['EndpointId'],
                        capabilities=json.loads(
                            endpoint_details['Capabilities']),
                        display_categories=json.loads(
                            endpoint_details['DisplayCategories']),
                        manufacturer_name=endpoint_details['ManufacturerName'])

                response = adr.get()

        else:
            alexa_error_response = AlexaResponse(name='ErrorResponse')
            alexa_error_response.set_payload({
                'type': 'INTERNAL_ERROR',
                'message': 'Empty Body'
            })
            response = alexa_error_response.get()

        if response is None:
            # response set to None indicates an unhandled directive, review the logs
            alexa_error_response = AlexaResponse(name='ErrorResponse')
            alexa_error_response.set_payload({
                'type':
                'INTERNAL_ERROR',
                'message':
                'Empty Response: No response processed. Unhandled Directive.'
            })
            response = alexa_error_response.get()

        print('LOG api_handler_directive.process.response -----')
        print(json.dumps(response))
        return response