Files del Alexa Skill para ordenar

Ordenar_Alexa/interactionModels/custom/en-US.json

@@ -0,0 +1,177 @@
+{
+  "interactionModel": {
+    "languageModel": {
+      "invocationName": "linguini order",
+      "intents": [
+        {
+          "name": "AMAZON.CancelIntent",
+          "samples": []
+        },
+        {
+          "name": "AMAZON.HelpIntent",
+          "samples": []
+        },
+        {
+          "name": "AMAZON.StopIntent",
+          "samples": []
+        },
+        {
+          "name": "HelloWorldIntent",
+          "slots": [],
+          "samples": [
+            "hello",
+            "how are you",
+            "say hi world",
+            "say hi",
+            "hi",
+            "say hello world",
+            "say hello"
+          ]
+        },
+        {
+          "name": "AMAZON.NavigateHomeIntent",
+          "samples": []
+        },
+        {
+          "name": "LinguiniOrderFoodIntent",
+          "slots": [
+            {
+              "name": "food_type",
+              "type": "food_type"
+            },
+            {
+              "name": "food_category",
+              "type": "food_category"
+            }
+          ],
+          "samples": [
+            "add {food_type} {food_category}",
+            "{food_type} {food_category}",
+            "order {food_type} {food_category}",
+            "add a {food_type} {food_category}",
+            "order a {food_type} {food_category}"
+          ]
+        },
+        {
+          "name": "LinguiniOrderDrinkIntent",
+          "slots": [
+            {
+              "name": "drink_type",
+              "type": "drink_type"
+            }
+          ],
+          "samples": [
+            "{drink_type}",
+            "add {drink_type}",
+            "order {drink_type}",
+            "add a {drink_type}",
+            "order a {drink_type}"
+          ]
+        },
+        {
+          "name": "LinguiniOrderReviewIntent",
+          "slots": [],
+          "samples": [
+            "review please",
+            "review"
+          ]
+        },
+        {
+          "name": "LinguiniOrderFinishIntent",
+          "slots": [],
+          "samples": [
+            "Finish"
+          ]
+        },
+        {
+          "name": "LinguiniOrderNothingIntent",
+          "slots": [],
+          "samples": [
+            "that is all",
+            "that\u0027s all",
+            "nothing else",
+            "nothing"
+          ]
+        }
+      ],
+      "types": [
+        {
+          "values": [
+            {
+              "name": {
+                "value": "pizzetta"
+              }
+            },
+            {
+              "name": {
+                "value": "pasta"
+              }
+            }
+          ],
+          "name": "food_category"
+        },
+        {
+          "values": [
+            {
+              "name": {
+                "value": "chicken alfredo"
+              }
+            },
+            {
+              "name": {
+                "value": "gardenia"
+              }
+            },
+            {
+              "name": {
+                "value": "carnivore"
+              }
+            },
+            {
+              "name": {
+                "value": "pepperoni"
+              }
+            },
+            {
+              "name": {
+                "value": "plain cheese"
+              }
+            }
+          ],
+          "name": "food_type"
+        },
+        {
+          "values": [
+            {
+              "name": {
+                "value": "beer"
+              }
+            },
+            {
+              "name": {
+                "value": "wine"
+              }
+            },
+            {
+              "name": {
+                "value": "juice"
+              }
+            },
+            {
+              "name": {
+                "value": "soda"
+              }
+            },
+            {
+              "name": {
+                "value": "water"
+              }
+            }
+          ],
+          "name": "drink_type"
+        }
+      ]
+    }
+  },
+  "version": "32"
+}

Ordenar_Alexa/lambda/lambda_function.py

@@ -0,0 +1,373 @@
+# -*- coding: utf-8 -*-
+
+# This sample demonstrates handling intents from an Alexa skill using the Alexa Skills Kit SDK for Python.
+# Please visit https://alexa.design/cookbook for additional examples on implementing slots, dialog management,
+# session persistence, api calls, and more.
+# This sample is built using the handler classes approach in skill builder.
+import logging
+import requests
+import ask_sdk_core.utils as ask_utils
+
+#from ask_sdk_s3.adapter import S3Adapter
+#s3_adapter = S3Adapter(bucket_name=os.environ["S3_PERSISTENCE_BUCKET"])
+
+from ask_sdk_core.skill_builder import SkillBuilder
+from ask_sdk_core.dispatch_components import AbstractRequestHandler
+from ask_sdk_core.dispatch_components import AbstractExceptionHandler
+from ask_sdk_core.handler_input import HandlerInput
+
+from ask_sdk_model import Response
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+ordernum = 0
+
+
+
+
+class LaunchRequestHandler(AbstractRequestHandler):
+    """Handler for Skill Launch."""
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+
+        return ask_utils.is_request_type("LaunchRequest")(handler_input)
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        speak_output = "What would you like to order?"
+
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                .ask(speak_output)
+                .response
+        )
+
+
+class HelloWorldIntentHandler(AbstractRequestHandler):
+    """Handler for Hello World Intent."""
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return ask_utils.is_intent_name("HelloWorldIntent")(handler_input)
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        speak_output = "Hello World!"
+
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                # .ask("add a reprompt if you want to keep the session open for the user to respond")
+                .response
+        )
+
+
+class LinguiniOrderFoodIntentHandler(AbstractRequestHandler):
+    """Handler for Linguini Order Food Intent."""
+    global ordernum 
+    ordernum = ordernum + 1
+    global food_dict
+    global order
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return ask_utils.is_intent_name("LinguiniOrderFoodIntent")(handler_input)
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        slots = handler_input.request_envelope.request.intent.slots
+        food_type = slots["food_type"].value
+        food_category = slots["food_category"].value
+        speak_output = f"One {food_type} {food_category} added to your order. What else would you like to add?"
+        food = f"{food_type} {food_category}"
+        
+        if food == "gardenia pasta":
+            orderstr = 'orden' + str(ordernum)
+            order[orderstr] = 2
+        else:
+            orderstr = 'orden' + str(ordernum)
+            order[ordernum] = 1
+        
+        if food in order_names:
+            order_names[food] += 1
+        else:
+            order_names[food] = 1
+        
+        handler_input.response_builder.speak(speak_output).ask("What else would you like to add?")
+        return (handler_input.response_builder.response)
+
+
+class LinguiniOrderDrinkIntentHandler(AbstractRequestHandler):
+    """Handler for Linguini Order Drink Intent."""
+    global ordernum
+    ordernum = ordernum + 1
+    global drink_dict
+    global order
+    global order_names
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return ask_utils.is_intent_name("LinguiniOrderDrinkIntent")(handler_input)
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        slots = handler_input.request_envelope.request.intent.slots
+        drink_type = slots["drink_type"].value
+        speak_output = f"One {drink_type} added to your order. What else would you like to add?"
+        
+        if drink_type == "water":
+            orderstr = 'orden' + str(ordernum)
+            order[orderstr] = 10
+        else:
+            orderstr = 'orden' + str(ordernum)
+            order[orderstr] = 9
+        
+        if drink_type in order_names:
+            order_names[drink_type] += 1
+        else:
+            order_names[drink_type] = 1
+        handler_input.response_builder.speak(speak_output).ask("What else would you like to add?")
+        return (handler_input.response_builder.response)
+
+
+class HelpIntentHandler(AbstractRequestHandler):
+    """Handler for Help Intent."""
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return ask_utils.is_intent_name("AMAZON.HelpIntent")(handler_input)
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        speak_output = "You can say hello to me! How can I help?"
+
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                .ask(speak_output)
+                .response
+        )
+
+
+class CancelIntentHandler(AbstractRequestHandler):
+    """Handler for Cancel Intent."""
+    global order
+    global order_names
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return (ask_utils.is_intent_name("AMAZON.CancelIntent")(handler_input))
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        speak_output = "Your order has been canceled."
+        order.clear()
+        order_names.clear()
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                .ask("reprompt")
+                .response
+        )
+
+
+class StopIntentHandler(AbstractRequestHandler):
+    """Handler for Stop Intent."""
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return (ask_utils.is_intent_name("AMAZON.StopIntent")(handler_input))
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        speak_output = "Alright! Your order is complete. Would you like to review, finish, or cancel your order?"
+
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                .ask(speak_output)
+                .response
+        )
+
+class LinguiniOrderNothingIntentHandler(AbstractRequestHandler):
+    """Handler for Stop Intent."""
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return (ask_utils.is_intent_name("LinguiniOrderNothingIntent")(handler_input))
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        speak_output = "Alright! Your order is complete. Would you like to review, finish, or cancel your order"
+
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                .ask(speak_output)
+                .response
+        )
+
+
+class LinguiniOrderReviewIntentHandler(AbstractRequestHandler):
+    global order
+    """Handler for Hello World Intent."""
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return ask_utils.is_intent_name("LinguiniOrderReviewIntent")(handler_input)
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        speak_output = "You have "
+        for i in order_names:
+            speak_output += f"{order_names[i]} {i}, "
+        speak_output = speak_output[:-2]
+        speak_output += ". If everything seems okay, say finish to submit order or say cancel to cancel and restart order." 
+        
+
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                .ask("add a reprompt if you want to keep the session open for the user to respond")
+                .response
+        )
+
+
+class LinguiniOrderFinishIntentHandler(AbstractRequestHandler):
+    global order
+    global order_names
+    """Handler for Hello World Intent."""
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return ask_utils.is_intent_name("LinguiniOrderFinishIntent")(handler_input)
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        #Send order to Restaurant lmao
+        
+        full_order = [{'nombre': 'Aranpompano','celular': '(555)-555-5555', 'ordenCompleta': order, 'peticiones': {}}]
+        #full_order = [{'nombre': 'Scott Pilgrim','celular': '(555)-555-5555', 'ordenCompleta': {'orden1':1, 'orden2': 10}, 'peticiones': {}}]
+        
+        try:
+            r = requests.post('http://136.145.231.48:5000/papelonDeComida', json=full_order)
+        except:
+            r = None
+        
+        if r == None:
+            speak_output = "Sorry, I couldn't connect to the restaurant. Please try again later."
+        
+        elif(r.status_code == 200):
+            speak_output = f'Alright! {r.text}'
+        else:
+            speak_output = "Uh oh! I couldn't place your order, please try again later."
+        
+        #REPLACE THIS WHEN API IS IMPLEMENTED
+        order.clear()
+        order_names.clear()
+        #REPLACE THIS WHEN API IS IMPLEMENTED
+
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                # .ask("add a reprompt if you want to keep the session open for the user to respond")
+                .response
+        )
+
+
+class SessionEndedRequestHandler(AbstractRequestHandler):
+    """Handler for Session End."""
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return ask_utils.is_request_type("SessionEndedRequest")(handler_input)
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+
+        # Any cleanup logic goes here.
+
+        return handler_input.response_builder.response
+
+
+class IntentReflectorHandler(AbstractRequestHandler):
+    """The intent reflector is used for interaction model testing and debugging.
+    It will simply repeat the intent the user said. You can create custom handlers
+    for your intents by defining them above, then also adding them to the request
+    handler chain below.
+    """
+    def can_handle(self, handler_input):
+        # type: (HandlerInput) -> bool
+        return ask_utils.is_request_type("IntentRequest")(handler_input)
+
+    def handle(self, handler_input):
+        # type: (HandlerInput) -> Response
+        intent_name = ask_utils.get_intent_name(handler_input)
+        speak_output = "You just triggered " + intent_name + "."
+
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                # .ask("add a reprompt if you want to keep the session open for the user to respond")
+                .response
+        )
+
+
+class CatchAllExceptionHandler(AbstractExceptionHandler):
+    """Generic error handling to capture any syntax or routing errors. If you receive an error
+    stating the request handler chain is not found, you have not implemented a handler for
+    the intent being invoked or included it in the skill builder below.
+    """
+    def can_handle(self, handler_input, exception):
+        # type: (HandlerInput, Exception) -> bool
+        return True
+
+    def handle(self, handler_input, exception):
+        # type: (HandlerInput, Exception) -> Response
+        logger.error(exception, exc_info=True)
+
+        speak_output = "Sorry, I had trouble doing what you asked. Please try again."
+
+        return (
+            handler_input.response_builder
+                .speak(speak_output)
+                .ask(speak_output)
+                .response
+        )
+
+# The SkillBuilder object acts as the entry point for your skill, routing all request and response
+# payloads to the handlers above. Make sure any new handlers or interceptors you've
+# defined are included below. The order matters - they're processed top to bottom.
+
+
+sb = SkillBuilder()
+try:
+    resp = requests.get('http://136.145.231.48:5000/retrieveMenu')
+    if resp.status_code == 200:
+        menu_full = resp.json()
+        food_dict = menu_full['comidas']
+        pasta_dict = comida['Pasta']
+        drink_dict = menu_full['bebidas']
+    else:
+        menu_full = {}
+        food_dict = {}
+        pasta_dict = {}
+        drink_dict = {}
+except:
+    menu_full = {}
+    food_dict = {}
+    pasta_dict = {}
+    drink_dict = {}
+    
+
+order = {}
+order_names = {}
+
+sb.add_request_handler(LaunchRequestHandler())
+#sb.add_request_handler(HelloWorldIntentHandler())
+#sb.add_request_handler(HelpIntentHandler())
+sb.add_request_handler(LinguiniOrderFoodIntentHandler())
+sb.add_request_handler(LinguiniOrderDrinkIntentHandler())
+sb.add_request_handler(LinguiniOrderNothingIntentHandler())
+sb.add_request_handler(CancelIntentHandler())
+sb.add_request_handler(StopIntentHandler())
+sb.add_request_handler(LinguiniOrderReviewIntentHandler())
+sb.add_request_handler(LinguiniOrderFinishIntentHandler())
+sb.add_request_handler(SessionEndedRequestHandler())
+sb.add_request_handler(IntentReflectorHandler()) # make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers
+
+sb.add_exception_handler(CatchAllExceptionHandler())
+
+lambda_handler = sb.lambda_handler()

Ordenar_Alexa/lambda/requirements.txt

@@ -0,0 +1,4 @@
+boto3==1.9.216
+requests==2.25.1
+ask-sdk-core==1.11.0
+ask-sdk-s3-persistence-adapter

Ordenar_Alexa/lambda/utils.py

@@ -0,0 +1,27 @@
+import logging
+import os
+import boto3
+from botocore.exceptions import ClientError
+
+
+def create_presigned_url(object_name):
+    """Generate a presigned URL to share an S3 object with a capped expiration of 60 seconds
+
+    :param object_name: string
+    :return: Presigned URL as string. If error, returns None.
+    """
+    s3_client = boto3.client('s3',
+                             region_name=os.environ.get('S3_PERSISTENCE_REGION'),
+                             config=boto3.session.Config(signature_version='s3v4',s3={'addressing_style': 'path'}))
+    try:
+        bucket_name = os.environ.get('S3_PERSISTENCE_BUCKET')
+        response = s3_client.generate_presigned_url('get_object',
+                                                    Params={'Bucket': bucket_name,
+                                                            'Key': object_name},
+                                                    ExpiresIn=60*1)
+    except ClientError as e:
+        logging.error(e)
+        return None
+
+    # The response contains the presigned URL
+    return response

Ordenar_Alexa/skill.json

@@ -0,0 +1,44 @@
+{
+  "manifest": {
+    "apis": {
+      "custom": {
+        "endpoint": {
+          "uri": "arn:aws:lambda:us-east-1:952171653410:function:d09b2dda-6a62-40cf-99b4-68aad50c5297:Release_0"
+        },
+        "interfaces": [],
+        "regions": {
+          "NA": {
+            "endpoint": {
+              "uri": "arn:aws:lambda:us-east-1:952171653410:function:d09b2dda-6a62-40cf-99b4-68aad50c5297:Release_0"
+            }
+          },
+          "EU": {
+            "endpoint": {
+              "uri": "arn:aws:lambda:eu-west-1:952171653410:function:d09b2dda-6a62-40cf-99b4-68aad50c5297:Release_0"
+            }
+          },
+          "FE": {
+            "endpoint": {
+              "uri": "arn:aws:lambda:us-west-2:952171653410:function:d09b2dda-6a62-40cf-99b4-68aad50c5297:Release_0"
+            }
+          }
+        }
+      }
+    },
+    "permissions": [
+      {
+        "name": "alexa::profile:given_name:read"
+      },
+      {
+        "name": "alexa::profile:mobile_number:read"
+      }
+    ],
+    "publishingInformation": {
+      "locales": {
+        "en-US": {
+          "name": "Linguini_Order"
+        }
+      }
+    }
+  }
+}