def handle(self, handler_input): #initialzing parameters persistent_attr,session_attr,greg_date,misri_date=util.init_parameters(handler_input) #set miqaat_status False initially for a new session session_attr["miqaat_status"]=False #Assign greet msg msg=data.GREET #Assign message for new users if(persistent_attr["first_login"] == True): msg=msg+util.set_greet(handler_input)+data.WELCOME_MSG_INIT+data.WELCOME_INTRO_MSG+data.WELCOME_CONNECTOR+data.WELCOME_MSG persistent_attr["first_login"] = False persistent_attr["last_session_set"]=greg_date.strftime("%D") return handler_input.response_builder.speak(msg).ask(data.WELCOME_MSG_ENG).response #If last session date doesn't match current date, update/set new values if(persistent_attr["last_session_set"]!=greg_date.strftime("%D")): msg=msg+util.set_greet(handler_input) persistent_attr["last_session_set"]=greg_date.strftime("%D") #for users where reminder is active, will fetch here the latest timings if(persistent_attr["reminder"] == True): #We avoid updating namaaz timings on phone, due to lack of support for progressive response phone=handler_input.request_envelope.context.system.device.supported_interfaces.geolocation if phone!=None: logger.info("***********its a phone***************") msg=msg+WELCOME_MSG return handler_input.response_builder.speak(msg).ask(data.WELCOME_MSG_ENG).response wait_msg=msg+data.WELCOME_MSG_INIT util.waiting(handler_input,wait_msg) _=util.unset_reminder(handler_input) logger.info("Deleted old reminders") status=util.set_reminder(handler_input) logger.info("activated new reminders") msg=data.WELCOME_CONNECTOR if status==-2: permissions=["read::alexa:device:all:address:country_and_postal_code"] msg=data.ERROR_LOCATION_MSG return handler_input.response_builder.speak(msg).set_card(AskForPermissionsConsentCard(permissions)).response if status==-1: permissions = ["alexa::alerts:reminders:skill:readwrite"] msg=data.MISSING_PERMISSIONS return handler_input.response_builder.speak(msg).set_card(AskForPermissionsConsentCard(permissions=permissions)).response if status==0: msg=data.REMINDER_ERR+data return handler_input.response_builder.speak(msg).ask(data.SESSION_STATUS).response msg=msg+data.WELCOME_MSG return handler_input.response_builder.speak(msg).ask(data.WELCOME_MSG_ENG).response
def handle(self, handler_input): # type: (HandlerInput) -> Response permissions = handler_input.request_envelope.context.system.user.permissions if not (permissions and permissions.consent_token): return (handler_input.response_builder.speak( "Please give permissions to set timers using the alexa app."). set_card( AskForPermissionsConsentCard( permissions=REQUIRED_PERMISSIONS)).response) duration_slot_value = ask_utils.get_slot_value(handler_input, 'duration') timer_request = get_custom_task_launch_timer(duration_slot_value) timer_service = handler_input.service_client_factory.get_timer_management_service( ) timer_response = timer_service.create_timer(timer_request) if str(timer_response.status) == "Status.ON": session_attr = handler_input.attributes_manager.session_attributes if not session_attr: session_attr['lastTimerId'] = timer_response.id speech_text = 'Your timer is now running!.' else: speech_text = 'Timer did not start' return (handler_input.response_builder.speak(speech_text).response)
def GetAddressIntent(handler_input): req_envelope = handler_input.request_envelope response_builder = handler_input.response_builder service_client_fact = handler_input.service_client_factory if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): response_builder.speak(NOTIFY_MISSING_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard(permissions=permissions)) return response_builder.response try: device_id = req_envelope.context.system.device.device_id device_addr_client = service_client_fact.get_device_address_service() addr = device_addr_client.get_full_address(device_id) if addr.address_line1 is None and addr.state_or_region is None: response_builder.speak(NO_ADDRESS) else: response_builder.speak(ADDRESS_AVAILABLE.format( addr.address_line1, addr.state_or_region, addr.postal_code)) return response_builder.response except ServiceException: response_builder.speak(ERROR) return response_builder.response except Exception as e: raise e
def handle(self, handler_input): language_prompts = handler_input.attributes_manager.request_attributes[ "_"] try: device_id = handler_input.request_envelope.context.system.device.device_id device_addr_client = handler_input.service_client_factory.get_device_address_service( ) addr = device_addr_client.get_full_address(device_id) if addr is None: handler_input.response_builder.speak( language_prompts["NO_ADDRESS"]) elif addr.address_line1 is None and addr.state_or_region is None: handler_input.response_builder.speak( language_prompts["NO_ADDRESS"]) else: handler_input.response_builder.speak( language_prompts["ADDRESS_AVAILABLE"].format( addr.address_line1, addr.state_or_region, addr.postal_code)) return handler_input.response_builder.response except ServiceException as exception: if exception.status_code == 403: return (handler_input.response_builder.speak( language_prompts["NOTIFY_MISSING_PERMISSIONS"]).set_card( AskForPermissionsConsentCard( permissions=permissions)).response) else: return (handler_input.response_builder.speak( language_prompts["LOCATION_FAILURE"]).ask( LOCATION_FAILURE).response)
def get_address(handler_input): req_envelope = handler_input.request_envelope response_builder = handler_input.response_builder service_client_fact = handler_input.service_client_factory if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): response_builder.speak(commands.NOTIFY_MISSING_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard(permissions=REQUIRED_PERMISSIONS)) return response_builder.response try: device_id = req_envelope.context.system.device.device_id device_addr_client = service_client_fact.get_device_address_service( ) addr = device_addr_client.get_full_address(device_id) if addr.address_line1 is None and addr.state_or_region is None: response_builder.speak(commands.NO_ADDRESS) else: return addr.address_line1 + ' ' + addr.state_or_region + ' ' + addr.postal_code except ServiceException: response_builder.speak(commands.ERROR) return response_builder.response except Exception as e: raise e
def set_up_amazon_pay(self, handler_input, charity_name): '''Customer has shown intent to purchase, call Setup to grab the customers shipping address detail and check amazon pay is set up''' # type: (HandlerInput, String) -> Response logger.info("In set_up_amazon_pay") # Permission check if is_missing_amazon_pay_permission(self, handler_input) is False: logger.info("Is FALSE") handler_input.response_builder.speak(data.PERMISSION_DENIED).set_card( AskForPermissionsConsentCard(['payments:autopay_consent' ])).set_should_end_session(True) return handler_input.response_builder.response logger.info("In set_up_amazon_pay again") foo = handler_input.request_envelope.request.locale token = 'correlationToken' message = data.DONATION_MADE_SPEECH + charity_name + " for " + \ str(amount_donated) + " dollars. Should I process your payment now?" # logger.info(message) logger.info("Before Sending Setup Directive") handler_input.response_builder.add_directive( SendRequestDirective(name="Setup", payload={ '@type': 'SetupAmazonPayRequest', '@version': '2', 'sellerId': 'A2G5K08S7KTD5R', 'countryOfEstablishment': 'US', 'ledgerCurrency': 'USD', 'checkoutLanguage': 'en-US', 'sandboxCustomerEmailId': '*****@*****.**', 'sandboxMode': True, 'needAmazonShippingAddress': True, 'billingAgreementAttributes': { '@type': 'BillingAgreementAttributes', '@version': '2', 'sellerNote': 'Thanks for your donation to ' + charity_name, 'platformId': None, 'sellerBillingAgreementAttributes': { '@type': 'SellerBillingAgreementAttributes', '@version': '2', 'sellerBillingAgreementId': 'BA12345', 'storeName': charity_name, 'customInformation': '' } } }, token="correlationToken")) handler_input.response_builder.speak(message) return handler_input.response_builder.response
def handle(self, handler_input, exception): if exception.status_code == 403: handler_input.response_builder.speak( NOTIFY_MISSING_PERMISSIONS).set_card( AskForPermissionsConsentCard(permissions=permissions)) else: handler_input.response_builder.speak(LOCATION_FAILURE).ask( LOCATION_FAILURE) return handler_input.response_builder.response
def handle(self, handler_input): logger.info("In LaunchRequestHandler") attributesManager = handler_input.attributes_manager sessionAttributes = attributesManager.session_attributes logger.info(sessionAttributes) speechText = getWelcomeMessage(sessionAttributes) + " " + getPrompt( sessionAttributes) return handler_input.response_builder.speak( speechText).ask(speechText).set_card( AskForPermissionsConsentCard(permissions)).response
def handle(self, handler_input, exception): if debugMode and exception: with open('exception.json', 'w') as writer: writer.write(str(exception)) if exception.status_code == 403: handler_input.response_builder.speak( NOTIFY_MISSING_PERMISSIONS).set_card( AskForPermissionsConsentCard(permissions=permissions)) else: handler_input.response_builder.speak(LOCATION_FAILURE).ask( LOCATION_FAILURE) return handler_input.response_builder.response
def handle(self, handler_input): # type: (HandlerInput) -> Response permissions = handler_input.request_envelope.context.system.user.permissions if not(permissions and permissions.consent_token): logger.info("user hasn't granted reminder permissions") return \ handler_input.response_builder.speak("Please give permissions to set reminders using the alexa app.") \ .set_card(AskForPermissionsConsentCard(permissions=REQUIRED_PERMISSIONS)) \ .response #Get the slot data slots = handler_input.request_envelope.request.intent.slots # userMedication = slots['userMedication'].value medicineDosage = slots['medicineDosage'].value medicineFrequency = slots['medicineFrequency'].value medicineTime = slots['medicineTime'].value #set the session attributes session_attributes = handler_input.attributes_manager.session_attributes # session_attributes['userMedication'] = userMedication session_attributes['medicineDosage'] = medicineDosage session_attributes['medicineFrequency'] = medicineFrequency session_attributes['medicineTime'] = medicineTime reminder_service = handler_input.service_client_factory.get_reminder_management_service() try: now = datetime.datetime.now(pytz.timezone(TIME_ZONE_ID)) #scheduled_time="2020-02-13T03:00:00.000" notification_time = datetime.datetime.today() times = [int(t) for t in medicineTime.split(':')] notification_time = notification_time.replace(hour=times[0], minute=times[1]).strftime("%Y-%m-%dT%H:%M:%S") trigger = Trigger(object_type=TriggerType.SCHEDULED_ABSOLUTE , scheduled_time=notification_time, time_zone_id=TIME_ZONE_ID, recurrence=Recurrence(freq=RecurrenceFreq.DAILY)) text = SpokenText(locale='en-US', ssml='<speak>This is your reminder for Kuvan</speak>', text='This is your reminder for Kuvan') alert_info = AlertInfo(SpokenInfo([text])) push_notification = PushNotification(PushNotificationStatus.ENABLED) reminder_request = ReminderRequest(notification_time, trigger, alert_info, push_notification) except ServiceException as e: logger.info("Exception encountered while creating Reminder: {}".format(e.body)) speech_text = "Uh Oh. Looks like something went wrong." return handler_input.response_builder.speak(speech_text).set_card( SimpleCard("Error while creating reminder.",str(e.body))).response speak_output = f'We have created {medicineFrequency} reminder at {medicineTime} for Kuvan' return ( handler_input.response_builder .speak(speak_output) .set_card(SimpleCard('Kuvan Reminder', speak_output)) # .ask("add a reprompt if you want to keep the session open for the user to respond") .response )
def handle(self, handler_input, exception): # type: (HandlerInput, Exception) -> Response logger.info("In HayBicisErrorHandler") logger.error(exception, exc_info=True) if (exception.status_code == 403): return (handler_input.response_builder.speak( NOTIFY_MISSING_PERMISSIONS).set_card( AskForPermissionsConsentCard( permissions=PERMISSIONS)).response) # not a permissions issue, so just return general failure return ( handler_input.response_builder.speak(LOCATION_FAILURE).response)
def space_station_intent_handler(handler_input): req_envelope = handler_input.request_envelope response_builder = handler_input.response_builder service_client_fact = handler_input.service_client_factory if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): response_builder.speak(NOTIFY_MISSING_PERMISSIONS) response_builder.set_card(AskForPermissionsConsentCard( permissions=permissions)) return response_builder.response try: device_id = req_envelope.context.system.device.device_id device_addr_client = service_client_fact.get_device_address_service() addr = device_addr_client.get_full_address(device_id) # Make sure we have some piece of address information before continuing if (addr.address_line1 is None and addr.state_or_region is None and addr.postal_code is None): response_builder.speak(NO_ADDRESS) else: # TODO: Move this else: into a helper function # Concat address components and pass to quote() to conver to URL safe string location = addr.address_line1 + " " + addr.state_or_region + " " + addr.postal_code locationURL = quote(location) # Form our request URL for google geo-code api to get coordinates base = "https://maps.googleapis.com/maps/api/geocode/json?" params = "address={address}&key={key}".format( address=locationURL, key="AIzaSyCVmqqeNXsmM3JKHW_-XGUq1MeUc9MQSeU") url = "{base}{params}".format(base=base, params=params) response = web_service_interface(url) # Save the formatted address from google for alexa to read out later location = response['results'][0]['formatted_address'] # Pass coordinates to open-notify.org API to find out when ISS will next pass lat = response['results'][0]['geometry']['location']['lat'] lon = response['results'][0]['geometry']['location']['lng'] result = web_service_interface('http://api.open-notify.org/iss-pass.json', lat, lon) # Convert timestamp to UTC and format in full date form so alexa reads clearly over = localtime(result['response'][1]['risetime']) over = strftime("%A %d %B %H:%M %Z", over) response_builder.speak(ADDRESS_AVAILABLE.format( over, location)) return response_builder.response except ServiceException: response_builder.speak(ERROR) return response_builder.response except Exception as e: raise e
def handle(self, handler_input): device_id = handler_input.request_envelope.context.system.device.device_id access_token = handler_input.request_envelope.context.system.api_access_token slots = handler_input.request_envelope.request.intent.slots diaSlot = slots['Days'].value proximoDiaAltura = [] proximoDiaHora = [] dadosAlturaHora = [] altura = [] headers = {"Authorization": f"Bearer {access_token}"} cep = requests.get( f"https://api.amazonalexa.com/v1/devices/{device_id}/settings/address/countryAndPostalCode", headers=headers) permissao = ['read::alexa:device:all:address:country_and_postal_code'] cep_dict = cep.json() codigoPostal = cep_dict['postalCode'] address = get_address_from_cep(f'{codigoPostal}', webservice=WebService.VIACEP) cidade = address['cidade'] cidade = cidade.lower() filtro = airtable.search('Data', str(data_atual)) for n, c in enumerate(filtro): dadosAlturaHora.append(filtro[n]['fields']) for v, c in enumerate(dadosAlturaHora): if dadosAlturaHora[v]['Lugar'] == cidade: proximoDiaAltura.append(dadosAlturaHora[v]['Altura']) proximoDiaHora.append(dadosAlturaHora[v]['Hora']) print(dadosAlturaHora[v]) for c in proximoDiaAltura: if float(c) < 1.0: altura.append('baixa') elif float(c) >= 1.0: altura.append('alta') diaUsado = diaSlot[8:10] respostaFinal = f'Amanhã, Às {proximoDiaHora[1]} a maré estará {altura[1]} com {proximoDiaAltura[1]}m de altura e às {proximoDiaHora[2]} a maré estará {altura[2]} com {proximoDiaAltura[2]}m de altura.' handler_input.response_builder.speak(respostaFinal).set_card( AskForPermissionsConsentCard( permissions=permissao)).set_should_end_session(True) return handler_input.response_builder.response
def handle(self, handler_input): req_envelope = handler_input.request_envelope response_builder = handler_input.response_builder if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): response_builder.speak(text.NOTIFY_MISSING_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard( permissions=permissions.FULL_ADDRESS)) return response_builder.response try: service_client_fact = handler_input.service_client_factory device_id = req_envelope.context.system.device.device_id device_addr_client = service_client_fact.get_device_address_service( ) addr = device_addr_client.get_full_address(device_id) #: uncomment for local development # addr.address_line1 = text.STREET # addr.city = text.CITY if addr.address_line1 is None or (addr.city and addr.postal_code is None): response_builder.speak(text.NO_ADDRESS) return response_builder.response except ServiceException: response_builder.speak(text.ERROR) return response_builder.response except Exception as exception: raise exception session_attributes = handler_input.attributes_manager.session_attributes session_attributes['address'] = { 'street': addr.address_line1, 'zone': addr.city or addr.postal_code } handler_input.response_builder \ .speak(text.WELCOME) \ .ask(text.WHAT_DO_YOU_WANT) \ .set_should_end_session(False) return handler_input.response_builder.response
def process(self, handler_input, response): sess_attrs = handler_input.attributes_manager.session_attributes i18n = get_i18n(handler_input) if response.output_speech: response.card = SimpleCard( title=i18n.SKILL_NAME, content=remove_ssml_tags(response.output_speech.ssml) ) if sess_attrs.get('show_permission_consent_card', False): sess_attrs['show_permission_consent_card'] = False response.card = AskForPermissionsConsentCard( ['alexa::profile:mobile_number:read'] )
def handle(self, handler_input): # type: (HandlerInput) -> Response rb = handler_input.response_builder request_envelope = handler_input.request_envelope permissions = request_envelope.context.system.user.permissions reminder_service = handler_input.service_client_factory.get_reminder_management_service( ) if not (permissions and permissions.consent_token): logging.info("user hasn't granted reminder permissions") return rb.speak("Please give permissions to set reminders using the alexa app.") \ .set_card(AskForPermissionsConsentCard(permissions=REQUIRED_PERMISSIONS)) \ .response attribute_manager = handler_input.attributes_manager session_attr = attribute_manager.session_attributes tz = pytz.timezone('America/Chicago') nt = datetime.fromtimestamp( session_attr['walking_time']).astimezone(tz) notification_time = nt.strftime("%Y-%m-%dT%H:%M:%S") logger.info("Notification Time {}".format(notification_time)) trigger = Trigger(TriggerType.SCHEDULED_ABSOLUTE, notification_time, time_zone_id=commands.TIME_ZONE_ID) text = SpokenText( locale='en-US', ssml= '<speak>This is your reminder to leave to get the next train</speak>', text='This is your reminder to leave to get the next train') alert_info = AlertInfo(SpokenInfo([text])) push_notification = PushNotification(PushNotificationStatus.ENABLED) reminder_request = ReminderRequest(notification_time, trigger, alert_info, push_notification) logger.info(reminder_request) try: reminder_response = reminder_service.create_reminder( reminder_request) except ServiceException as e: # see: https://developer.amazon.com/docs/smapi/alexa-reminders-api-reference.html#error-messages logger.error(e) raise e return rb.speak("reminder created") \ .set_card(SimpleCard("Notify Me", "leave to get the next train")) \ .set_should_end_session(True) \ .response
def handle(self, handler_input): # type: (HandlerInput) -> Response reminder_client = handler_input.service_client_factory.get_reminder_management_service() req_envelope = handler_input.request_envelope response_builder = handler_input.response_builder # Check if user gave permissions to create reminders. # If not, request to provide permissions to the skill. if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): response_builder.speak(NOTIFY_MISSING_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard(permissions=permissions)) return response_builder.response try: reminder_response = reminder_client.create_reminder( reminder_request=ReminderRequest( request_time=datetime.utcnow(), trigger=Trigger( object_type=TriggerType.SCHEDULED_RELATIVE, offset_in_seconds=60), alert_info=AlertInfo( spoken_info=SpokenInfo( content=[SpokenText(locale="en-US", text="Test reminder")])), push_notification=PushNotification( status=PushNotificationStatus.ENABLED))) # type: ReminderResponse speech_text = "Great! I've scheduled a reminder for you." logger.info("Created reminder : {}".format(reminder_response)) return handler_input.response_builder.speak(speech_text).set_card( SimpleCard( "Reminder created with id", reminder_response.alert_token)).response except ServiceException as e: logger.info("Exception encountered : {}".format(e.body)) speech_text = "Uh Oh. Looks like something went wrong." return handler_input.response_builder.speak(speech_text).set_card( SimpleCard( "Reminder not created",str(e.body))).response speak_output = "Your reminder has been scheduled successfully." return ( handler_input.response_builder .speak(speak_text) # .ask("add a reprompt if you want to keep the session open for the user to respond") .response )
def handle(self, handler_input): # type: (HandlerInput) -> Response logger.info("In HayBicisIntentHandler") service_client_fact = handler_input.service_client_factory response_builder = handler_input.response_builder if not (get_api_access_token(handler_input)): logger.info("no api access token") response_builder.speak(NOTIFY_MISSING_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard(permissions=PERMISSIONS)) return response_builder.response try: device_id = get_device_id(handler_input) device_addr_client = service_client_fact.get_device_address_service( ) addr = device_addr_client.get_full_address(device_id) logger.info(addr) logger.info( 'Location API response retrieved, now building response') if not addr.city.lower() == "barcelona": return handler_input.response_builder.speak( NO_ADDRESS).response else: geolocator = Nominatim(user_agent="hay-bicis") address = "{}, Barcelona, {}".format(addr.address_line1, addr.postal_code) logger.info(address) coordinates = geolocator.geocode(address) closest = self.get_closest_distance(coordinates.latitude, coordinates.longitude) bikes_available = self.get_bikes(closest) return ( handler_input.response_builder.speak(bikes_available).response) except ServiceException as e: logger.error("error reported by device location service") raise e except Exception as e: logger.error(e, exc_info=True) return handler_input.response_builder.speak(ERROR)
def check_reminders_permissions(handler_input): """Check and possibly ask permissions for Reminders """ # type: (HandlerInput) -> Bool #check permissions for the Reminder permissions = ["alexa::alerts:reminders:skill:readwrite"] req_envelope = handler_input.request_envelope response_builder = handler_input.response_builder # Check if user gave permissions to create reminders. # If not, request to provide permissions to the skill. if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): response_builder.speak(NOTIFY_MISSING_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard(permissions=permissions)) return False logger.info("Permissions are OK") return True
def handle(self, handler_input): # type: (HandlerInput) -> Response global user_name global receiver_email req_envelope = handler_input.request_envelope if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): user_name = '' receiver_email = None else: apiaccessToken = handler_input.request_envelope.context.system.api_access_token key = 'Bearer ' + apiaccessToken headers = { "Host": "api.amazonalexa.com", "Authorization": key, "Accept": "application/json" } URL = "https://api.amazonalexa.com/v2/accounts/~current/settings/Profile.givenName" jname = requests.get(url=URL, headers=headers) user_name = jname.json() if not isinstance(user_name, str): user_name = '' URL = "https://api.amazonalexa.com/v2/accounts/~current/settings/Profile.email" jemail = requests.get(url=URL, headers=headers) receiver_email = jemail.json() if not isinstance(receiver_email, str): receiver_email = None if receiver_email is None or user_name == '': speech_text = "Welcome " + user_name + ", I am ChemVox, the voice of TeraChem. If you grant the permissions to access your email address and name in the skill setting, I will email you the results. How can I help you?" handler_input.response_builder.speak(speech_text).set_card( AskForPermissionsConsentCard( permissions=permissions)).set_should_end_session(False) else: speech_text = "Welcome " + user_name + ", I am ChemVox, the voice of TeraChem. How can I help you?" small = "https://chemvox.s3.us-east-2.amazonaws.com/" + str( random.randint(1, 6)) + ".png" pict = Image(small) handler_input.response_builder.speak(speech_text).set_card( StandardCard("ChemVox", speech_text, pict)).set_should_end_session(False) return handler_input.response_builder.response
def handle(self, handler_input): # type: (HandlerInput) -> Response attr = handler_input.attributes_manager.session_attributes if not attr: attr['business_name'] = 'Unknown' attr['business_phone_number'] = 0 handler_input.attributes_manager.session_attributes = attr speak_output = ( "Welcome to Safe Plate, you can search for restaurant health inspection scores by name or phone number or ask for Help. " "This skill requires permission to create to do list entries. " "Look in the alexa app to grant this permission.") logger.info("Starting Skill") return (handler_input.response_builder.speak(speak_output).set_card( AskForPermissionsConsentCard( permissions=permissions)).ask(speak_output).response)
def notify_me_intent_handler(handler_input: HandlerInput) -> Response: """Handler for Notify Me Intent.""" logging.info("running notify_me_intent_handler()") rb = handler_input.response_builder request_envelope = handler_input.request_envelope permissions = request_envelope.context.system.user.permissions reminder_service = handler_input.service_client_factory.get_reminder_management_service( ) if not (permissions and permissions.consent_token): logging.info("user hasn't granted reminder permissions") return rb.speak("Please give permissions to set reminders using the alexa app.") \ .set_card(AskForPermissionsConsentCard(permissions=REQUIRED_PERMISSIONS)) \ .response now = datetime.datetime.now(pytz.timezone(TIME_ZONE_ID)) five_mins_from_now = now + datetime.timedelta(minutes=+5) notification_time = five_mins_from_now.strftime("%Y-%m-%dT%H:%M:%S") trigger = Trigger(TriggerType.SCHEDULED_ABSOLUTE, notification_time, time_zone_id=TIME_ZONE_ID) text = SpokenText(locale='en-US', ssml='<speak>This is your reminder</speak>', text='This is your reminder') alert_info = AlertInfo(SpokenInfo([text])) push_notification = PushNotification(PushNotificationStatus.ENABLED) reminder_request = ReminderRequest(notification_time, trigger, alert_info, push_notification) try: reminder_responce = reminder_service.create_reminder(reminder_request) except ServiceException as e: # see: https://developer.amazon.com/docs/smapi/alexa-reminders-api-reference.html#error-messages logger.error(e) raise e return rb.speak("reminder created") \ .set_card(SimpleCard("Notify Me", "reminder created")) \ .set_should_end_session(True) \ .response
def handle(self, handler_input: HandlerInput) -> Response: try: home_address = self.get_home_address(handler_input) except HomeAddressForbiddenException: handler_input.response_builder.speak( 'Please enable Location permissions in the Alexa app.' ).set_card( AskForPermissionsConsentCard( permissions=["read::alexa:device:all:address" ])).set_should_end_session(True) return handler_input.response_builder.response cars = get_cars_from_request(handler_input.request_envelope) sentences = [status_phrase(car, home_address) for car in cars] speech_text = ' '.join(sentences) handler_input.response_builder.speak( speech_text).set_should_end_session(True) return handler_input.response_builder.response
def handle(self, handler_input): # type: (HandlerInput) -> Response attrib_manager = handler_input.attributes_manager req_envelope = handler_input.request_envelope session_attrs = attrib_manager.session_attributes intent_context = req_envelope.context.system if not (req_envelope.context.system.user.permissions and req_envelope.context.system.user.permissions.consent_token): handler_input.response_builder.speak( NOTIFY_MISSING_PERMISSIONS).ask(CONTINUE_QUESTION) handler_input.response_builder.set_card( AskForPermissionsConsentCard(permissions=permissions)) return handler_input.response_builder.response try: uri = intent_context.api_endpoint api_access = intent_context.api_access_token geter = "/v2/accounts/~current/settings/Profile.email" headers = { 'Content-type': 'application/json', 'Authorization': 'Bearer {}'.format(api_access), } x = requests.get(uri + geter, headers=headers) to_email = x.text print(x) # print(to_email) send_email(to_email, session_attrs['cur_q']) speech_text = "Your email is on the way. It will reach you at {}".format( to_email) + CONTINUE_QUESTION handler_input.response_builder.speak(speech_text).ask( CONTINUE_QUESTION).set_should_end_session(False) except Exception as e: speech_text = "Tell me a topic first. For example, queue" handler_input.response_builder.speak(speech_text).ask( CONTINUE_QUESTION).set_should_end_session(False) return handler_input.response_builder.response
def handle(self, handler_input): # type: (HandlerInput) -> Response request_envelope = handler_input.request_envelope permissions = request_envelope.context.system.user.permissions reminder_service = handler_input.service_client_factory.get_reminder_management_service( ) if not (permissions and permissions.consent_token): return (handler_input.response_builder.speak( "Please give permissions to set reminders " "using the alexa app.").set_card( AskForPermissionsConsentCard( permissions=REQUIRED_PERMISSIONS)).response) now = datetime.datetime.now(pytz.timezone(TIME_ZONE_ID)) one_min_from_now = now + datetime.timedelta(minutes=+1) notification_time = one_min_from_now.strftime("%Y-%m-%dT%H:%M:%S") trigger = Trigger(TriggerType.SCHEDULED_ABSOLUTE, notification_time, time_zone_id=TIME_ZONE_ID) text = SpokenText(locale='en-US', ssml='<speak>This is your reminder</speak>', text='This is your reminder') alert_info = AlertInfo(SpokenInfo([text])) push_notification = PushNotification(PushNotificationStatus.ENABLED) reminder_request = ReminderRequest(notification_time, trigger, alert_info, push_notification) try: reminder_response = reminder_service.create_reminder( reminder_request) except ServiceException as error: logger.error(error) raise error return ( handler_input.response_builder.speak("Reminder Created").response)
def handle(self, handler_input): # type: (HandlerInput) -> Response logger.info("In GetAddressIntentHandler") service_client_fact = handler_input.service_client_factory response_builder = handler_input.response_builder if not (get_api_access_token(handler_input)): logger.info("no api access token") response_builder.speak(NOTIFY_MISSING_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard(permissions=PERMISSIONS)) return response_builder.response try: device_id = get_device_id(handler_input) device_addr_client = service_client_fact.get_device_address_service( ) addr = device_addr_client.get_full_address(device_id) logger.info( 'Location API response retrieved, now building response') if addr.address_line1 is None and addr.state_or_region is None: response_builder.speak(NO_ADDRESS) else: response_builder.speak( ADDRESS_AVAILABLE.format(addr.address_line1, addr.state_or_region, addr.postal_code)) return response_builder.response except ServiceException as e: logger.error("error reported by device location service") raise e except Exception as e: logger.error(e, exc_info=True) return handler_input.response_builder.speak(ERROR)
def handle(self, handler_input): device_id = handler_input.request_envelope.context.system.device.device_id access_token = handler_input.request_envelope.context.system.api_access_token horaInicial = [] dadosAlturaHora = [] headers = {"Authorization": "Bearer " + access_token} cep = requests.get( f"https://api.amazonalexa.com/v1/devices/{device_id}/settings/address/countryAndPostalCode", headers=headers) permissao = ['read::alexa:device:all:address:country_and_postal_code'] if cep.status_code == 200: cep_dict = cep.json() codigoPostal = cep_dict['postalCode'] address = get_address_from_cep(f'{codigoPostal}', webservice=WebService.APICEP) cidade = address['cidade'] speak_output = f'Bem-vindo a Skill de Marés Brasileiras. Você deseja ver a maré da cidade de {cidade}? Se não, diga-me o nome da cidade desejada.' handler_input.response_builder.speak( speak_output).ask(speak_output).set_card( SimpleCard('Início', speak_output)).set_should_end_session(False) return handler_input.response_builder.response speak_output = 'OK' cep_dict = cep.json() print(cep) handler_input.response_builder.speak(speak_output).set_card( AskForPermissionsConsentCard( permissions=permissao)).set_should_end_session(True) return handler_input.response_builder.response
def handle(self, handler_input): # type: (HandlerInput) -> Response logger.info("In Connections Response Handler") response_payload = handler_input.request_envelope.request.payload response_status = response_payload['status'] #logger.info("Status value is --> {}".format(response_status)) if (response_status == 'NOT_ANSWERED'): return handler_input.response_builder.speak( "Please provide Reminder permission using the card I have sent to your Alexa app." ).set_card( AskForPermissionsConsentCard(permissions=PERMISSIONS)).response elif (response_status == 'DENIED'): return handler_input.response_builder.speak( "You can grant permission anytime by going to Alexa app" ).response else: return handler_input.response_builder.speak( "Do you want to schedule a medicine reminder?").ask( "What do you want to do?").response
def get_response_and_coordinate(handler_input): """returns response_builder, Coordinate (optional)""" coordinate = None request_envelope = handler_input.request_envelope response_builder = handler_input.response_builder user_permissions = request_envelope.context.system.user.permissions # get data necessary for geolocation access location_services_supported = request_envelope.context.geolocation is not None try: geolocation_granted = ( user_permissions.scopes["alexa::devices:all:geolocation:read"]. status.value == PermissionStatus.GRANTED.value) except (AttributeError, ValueError, KeyError) as e: geolocation_granted = False # get data necessary for address access device_id = request_envelope.context.system.device.device_id api_access_token = request_envelope.context.system.api_access_token try: service_client_factory = handler_input.service_client_factory device_addr_client = service_client_factory.get_device_address_service( ) address = device_addr_client.get_full_address(device_id) address_access = True except ServiceException: address_access = False address = None if location_services_supported: # if geo location services are supported if geolocation_granted: # if we have permissions we've got a coordinate! try: # TODO I can't figure out how to pass a subscriptable object in test coordinate = request_envelope.context.geolocation["coordinate"] except TypeError: coordinate = request_envelope.context.geolocation.coordinate.to_dict( ) return response_builder.response, coordinate # return build_detailed_response_for_coordinate(response_builder, coordinate) else: # if not and we don't have access to address, we'll have to ask for something if not address_access: response_builder.speak(NOTIFY_MISSING_LOCATION_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard( permissions=GEOLOCATION_PERMISSIONS)) return response_builder.response, coordinate if address_access: # if we haven't returned somethng and do have address access coordinate = get_coordinate_from_address_response(address) if coordinate is None: response_builder.speak(NOTIFY_BAD_ADDRESS).set_card( SimpleCard( title=NOTIFY_BAD_ADDRESS_TITLE, content=NOTIFY_BAD_ADDRESS)).set_should_end_session(True) return response_builder.response, coordinate else: return response_builder.response, coordinate else: # if we don't have access to anything thus far we'll need address permissions response_builder.speak(NOTIFY_MISSING_ADDRESS_PERMISSIONS) response_builder.set_card( AskForPermissionsConsentCard(permissions=ADDRESS_PERMISSIONS)) return response_builder.response, coordinate return response_builder.response, coordinate
def handle(self, handler_input): """Handle the intent; fetch and serve appropriate response. Handles prompt response if one exists (ie. if this was called as an updated_intent from NextMassIntent). Unless told not to, creates a reminder via the reminder API for 30 minutes prior to mass, handling edge cases such as being within a 30 minute window of next mass OR lack of Reminder permissions by the user. Supports a DEV_MODE for a quick reminder. Ends the current session. Args: handler_input (ask_sdk_core.handler_input.HandlerInput): Input from Alexa. Returns: ask_sdk_model.response.Response: Response for this intent and device. """ DEV_MODE = False speech = "" LOGGER.info("Running NotifyNextMassHandler") userSession = session.KilianUserSession(handler_input) negativeResponses = ["nah", "nope", "no thank you", "no thanks", "no"] # Did this intent come from an updated_intent redirect? Was the user # just asked a yes/no question?: if userSession.desiresReminder: # Yup, check for a negative answer and bail. if userSession.desiresReminder.lower() in negativeResponses: LOGGER.info("DESIRES_REMINDER slot indicates 'no'") speech = "Okay." cardTitle = "Next Mass" cardText = "No reminder requested." handler_input.response_builder.speak(speech).set_card( StandardCard(title=cardTitle, text=cardText)) handler_input.response_builder.set_should_end_session(True) return handler_input.response_builder.response else: # Nope, the user must have explicitly asked for the reminder. LOGGER.info("No DESIRES_REMINDER slot filled.") # Set up the reminder framework: responseBuilder = handler_input.response_builder requestEnvelope = handler_input.request_envelope permissions = requestEnvelope.context.system.user.permissions serviceFactory = handler_input.service_client_factory reminderService = serviceFactory.get_reminder_management_service() # If no permissions if not (permissions and permissions.consent_token): LOGGER.info("user hasn't granted reminder permission") speech = "Please give Saint Kilian permissions to set reminders" speech += " using your Alexa app." permissions = ["alexa::alerts:reminders:skill:readwrite"] card = AskForPermissionsConsentCard(permissions=permissions) return responseBuilder.speak(speech).set_card(card).response # Else, let's set up the reminder msg = "Necessary permissions found. Creating reminder." print(msg) LOGGER.info(msg) now = datetime.datetime.now(pytz.timezone("America/Los_Angeles")) massTime = events.MassResponse(userSession).getNextMass() msg = "massTime getNextMass query returned" print(msg) LOGGER.debug(msg) # If no more masses today: if not massTime: LOGGER.info("no next mass found for today") speech = "Sorry, but it looks like there are no more masses today." cardText = "No more masses today.\nTry again tomorrow." card = SimpleCard("St. Kilian - Mass Reminder", cardText) return responseBuilder.speak(speech).set_card(card) \ .set_should_end_session(True).response # Good, a mass was found. Convert it to the local timezone. msg = "Mass found. Converting to local timezone" print(msg) LOGGER.debug(msg) massTime = massTime["time"] todayEvent = datetime.datetime.combine(now, massTime) reminderTime = todayEvent - datetime.timedelta(minutes=30) timezone = pytz.timezone("America/Los_Angeles") reminderTime = timezone.localize(reminderTime) todayEvent = timezone.localize(todayEvent) msg = "Upcoming event, local time, is {}".format(todayEvent) print(msg) LOGGER.debug(msg) # Are we within 30 minutes before it starts? If so, apologize and bail. if reminderTime < now and not DEV_MODE: LOGGER.info("too late. reminder is in the past.") speech = "It looks like it's too late for a reminder. " left = int(((todayEvent - now).seconds) / 60) speech += "You only have {} minutes left until Mass.".format(left) card = SimpleCard("St. Kilian - Mass Reminder", "Reminder set for Mass.") return responseBuilder.speak(speech).set_card(card) \ .set_should_end_session(True).response # Rather than waiting all day, if in dev mode, just wait one minute: if DEV_MODE: reminderTime = now + datetime.timedelta(minutes=+1) # Build and invoke the response: msg = "Building response" print(msg) LOGGER.debug(msg) reminderString = reminderTime.strftime("%Y-%m-%dT%H:%M:%S") trigger = Trigger(TriggerType.SCHEDULED_ABSOLUTE, reminderString, time_zone_id="America/Los_Angeles") msg = "It is time to leave for mass." markup = "<speak>{}</speak>".format(msg) reminderSpeech = SpokenText(locale="en-US", ssml=markup, text=msg) alertInfo = AlertInfo(SpokenInfo(content=[reminderSpeech])) pushNotification = PushNotification(PushNotificationStatus.ENABLED) reminderRequest = ReminderRequest(request_time=reminderTime, trigger=trigger, alert_info=alertInfo, push_notification=pushNotification) try: LOGGER.debug("creating reminder...") print("creating reminder...") reminderService.create_reminder(reminder_request=reminderRequest) LOGGER.debug("reminder created.") except ServiceException as e: msg = "An error occurred while creating reminder from\n{}" msg = msg.format(reminderRequest) print(msg) LOGGER.error(msg) LOGGER.error(e) if hasattr(e, "message"): LOGGER.error(e.message) raise e # Build the speech response: if DEV_MODE: speech += "Okay. Since you are in demo mode, I'll remind " speech += "in one minute to go to mass. " speech += "I will remind you at {}:{}{} to leave for mass." hour = reminderTime.hour minute = "{:02d}".format(reminderTime.minute) if hour >= 12: suffix = "pm" else: suffix = "am" if hour > 12: hour = hour - 12 speech = speech.format(hour, minute, suffix) card = SimpleCard("St. Kilian", "Reminder set for Mass.") msg = "returning final response." print(msg) return responseBuilder.speak(speech).set_card(card) \ .set_should_end_session(True).response