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
