def submit(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Define what the form has to do
after all required slots are filled"""
db = pymysql.connect('localhost', 'rasauser', 'rasapassword', 'rasa')
cursor = db.cursor()
name = tracker.get_slot('name')
email = tracker.get_slot('email')
password = tracker.get_slot('password')
sql = f" INSERT INTO PERSON VALUES (NULL, '{name}', '{email}', '{password}')"
try:
cursor.execute(sql)
db.commit()
except pymysql.Error as exc:
print("error inserting...\n {}".format(exc))
finally:
db.close()
# utter submit template
dispatcher.utter_template('utter_submit', tracker)
return []
def submit(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Once we have all the information, attempt to add it to the
Google Drive database"""
import datetime
budget = tracker.get_slot('budget')
company = tracker.get_slot('company')
email = tracker.get_slot('business_email')
job_function = tracker.get_slot('job_function')
person_name = tracker.get_slot('person_name')
use_case = tracker.get_slot('use_case')
date = datetime.datetime.now().strftime("%d/%m/%Y")
sales_info = [company, use_case, budget, date, person_name,
job_function, email]
gdrive = GDriveService()
try:
gdrive.store_data(sales_info)
dispatcher.utter_template('utter_confirm_salesrequest', tracker)
return []
except Exception as e:
logger.error("Failed to write data to gdocs. Error: {}"
"".format(e.message), exc_info=True)
dispatcher.utter_template('utter_salesrequest_failed', tracker)
return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
#save in the slot the information that we got
number_of_people = int(tracker.get_slot("num_persone"))
orario = tracker.get_slot("orario")
data = tracker.get_slot("data")
prenotation_time = data + "T" + orario
global number_of_seats
service = authentication()
if ":" == prenotation_time[-3:-2]:
prenotation_time = prenotation_time[:-3] + prenotation_time[
-2:] # formattazione orario per chiamate successive
prenotation_time_start = datetime.strptime(prenotation_time,
'%Y-%m-%dT%H:%M:%S.%f%z')
prenotation_time_end = prenotation_time_start + timedelta(
hours=2) # si assume che una prenotazione duri 2 ore
events_result = service.events().list(
calendarId='*****@*****.**',
timeMin=prenotation_time_start.isoformat(),
timeMax=prenotation_time_end.isoformat()).execute()
events = events_result.get('items', [])
if check_available_seats(
events, number_of_people
): # si controlla che ci siano posti disponibili
dispatcher.utter_template("utter_confirmation", tracker)
return [SlotSet('available_seats', True)]
else:
dispatcher.utter_message("Mi dispiace ma siamo al completo.")
return [SlotSet('available_seats', False)]
def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Define what the form has to do after all required slots are filled"""
location = tracker.get_slot('location')
speciality = tracker.get_slot('speciality')
results = _find_providers(location, speciality)
buttons = []
for r in results:
provider_id = r.get("provider_id")
provider_name = r.get("provider_name")
payload = "/inform{\"provider_id\":\"" + provider_id + "\"}"
buttons.append({
"title": "{}".format(provider_name.title()),
"payload": payload
})
# limit number of buttons to 3 here for clear presentation purpose
dispatcher.utter_button_message(
"Here is a list of {} {} near you".format(len(buttons[:3]),
"providers"),
buttons[:3],
button_type="vertical")
# todo: note: button options are not working BUG in rasa_core
# utter submit template
dispatcher.utter_template('utter_submit', tracker)
return []
def validate(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
slot_values = self.extract_other_slots(dispatcher, tracker, domain)
slot_to_fill = tracker.get_slot(REQUESTED_SLOT)
if slot_to_fill:
slot_values.update(self.extract_requested_slot(dispatcher,
tracker, domain))
if not slot_values:
raise ActionExecutionRejection(self.name(),
"Failed to validate slot {0}"
"with action {1}"
"".format(slot_to_fill,
self.name()))
for slot, value in slot_values.items():
if slot == "TypeOfVehicle":
if value not in self.TypeOfVehicle_db():
dispatcher.utter_template('utter_wrong_TypeOfVehicle', tracker)
# validation failed, set slot to None
slot_values[slot] = None
# validation succeed, set the slots values to the extracted values
return [SlotSet(slot, value) for slot, value in slot_values.items()]
def validate(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Validate extracted requested slot
else reject the execution of the form action
"""
# extract other slots that were not requested
# but set by corresponding entity
slot_values = self.extract_other_slots(dispatcher, tracker, domain)
# extract requested slot
slot_to_fill = tracker.get_slot(REQUESTED_SLOT)
if slot_to_fill:
slot_values.update(
self.extract_requested_slot(dispatcher, tracker, domain))
if not slot_values:
# reject form action execution
# if some slot was requested but nothing was extracted
# it will allow other policies to predict another action
raise ActionExecutionRejection(
self.name(), "Failed to validate slot {0} "
"with action {1}"
"".format(slot_to_fill, self.name()))
# we'll check when validation failed in order
# to add appropriate utterances
for slot, value in slot_values.items():
if slot == 'date':
if self.date_validation(value) == False:
dispatcher.utter_template('utter_wrong_date', tracker)
slot_values[slot] = None
# validation succeed, set the slots values to the extracted values
return [SlotSet(slot, value) for slot, value in slot_values.items()]
def submit(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
# utter submit template
dispatcher.utter_template('utter_submit', tracker)
return []
def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Define what the form has to do
after all required slots are filled"""
# utter submit template
dispatcher.utter_template('utter_submit', tracker)
return []
def validate(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Validate extracted requested slot
else reject the execution of the form action
"""
# extract other slots that were not requested
# but set by corresponding entity
slot_values = self.extract_other_slots(dispatcher, tracker, domain)
# extract requested slot
slot_to_fill = tracker.get_slot(REQUESTED_SLOT)
if slot_to_fill:
slot_values.update(self.extract_requested_slot(dispatcher,
tracker, domain))
if not slot_values:
# reject form action execution
# if some slot was requested but nothing was extracted
# it will allow other policies to predict another action
raise ActionExecutionRejection(self.name(),
"Failed to validate slot {0} "
"with action {1}"
"".format(slot_to_fill,
self.name()))
# we'll check when validation failed in order
# to add appropriate utterances
for slot, value in slot_values.items():
if slot == 'crop' or slot == 'product':
if value.lower() not in self.cuisine_db():
dispatcher.utter_template('utter_wrong_cuisine', tracker)
# validation failed, set slot to None
slot_values[slot] = None
# elif slot == 'num_people':
# if not self.is_int(value) or int(value) <= 0:
# dispatcher.utter_template('utter_wrong_num_people',
# tracker)
# # validation failed, set slot to None
# slot_values[slot] = None
# elif slot == 'outdoor_seating':
# if isinstance(value, str):
# if 'out' in value:
# # convert "out..." to True
# slot_values[slot] = True
# elif 'in' in value:
# # convert "in..." to False
# slot_values[slot] = False
# else:
# dispatcher.utter_template('utter_wrong_outdoor_seating',
# tracker)
# # validation failed, set slot to None
# slot_values[slot] = None
# validation succeed, set the slots values to the extracted values
return [SlotSet(slot, value) for slot, value in slot_values.items()]
def validate_num_persone(self, value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker, domain: Dict[Text, Any]):
if self.is_int(value):
return value
else:
dispatcher.utter_template('utter_default_incomprensione', tracker)
return None
def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
persona = tracker.get_slot('persona')
if persona is not None:
dispatcher.utter_template("utter_saludo_nombre", tracker,
**tracker.slots)
return [SlotSet('persona', persona)]
else:
dispatcher.utter_template("utter_saludo", tracker)
return []
def submit(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Define what the form has to do
after all required slots are filled"""
"""in other words from here the applicant data goes to the database"""
# utter submit template
dispatcher.utter_template('action_store_applicant', tracker)
return []
def validate_num_people(self, value: Text,
dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> Optional[Text]:
"""Validate num_people value."""
if self.is_int(value) and int(value) > 0:
return value
else:
dispatcher.utter_template('utter_wrong_num_people', tracker)
# validation failed, set slot to None
return None
def validate_stars(self, value: Text, dispatcher: CollectingDispatcher,
tracker: Tracker, domain: Dict[Text,
Any]) -> Optional[Text]:
"""Validate stars value."""
if self.is_int(value) and int(value) > 0 and int(value) < 6:
return {"stars": value}
else:
dispatcher.utter_template('utter_wrong_stars', tracker)
# validation failed, set slot to None
return {"stars": None}
def validate_cv_link(value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> Any:
CV_LINK_REGEX = re.compile(r'''[https:\/\/]*[www.]*linkedin.[com | org | tn | fr | me]+[\\/in\\/]*[a-z A-z 0-9 -]+''')
if CV_LINK_REGEX.match(value):
return value
else:
dispatcher.utter_template('utter_wrong_cv_link', tracker)
# validation failed, set slot to None
return None
def validate_budget(self,
value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> Optional[Text]:
budget = zomato_utils.get_valid_budget(value)
if budget['is_valid']:
self.budget_type = budget["type"]
return value
else:
dispatcher.utter_template('utter_wrong_budget', tracker)
return None
def validate_position(self, value: Text, dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> Optional[Text]:
if value.lower() in self.position_db():
# validation succeeded
return {"position": value}
else:
dispatcher.utter_template('utter_wrong_option', tracker)
# validation failed, set this slot to None, meaning the
# user will be asked for the slot again
return {"position": None}
def validate_email(value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> Any:
EMAIL_REGEX = re.compile(r"[a-z A-Z]+[0-9 a-z A-Z]*@[a-z A-Z]+[.][a-z A-Z]+")
if EMAIL_REGEX.match(value):
return value
else:
dispatcher.utter_template('utter_wrong_email', tracker)
# validation failed, set slot to None
return None
def validate_cuisine(self,
value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> Optional[Text]:
cuisine = zomato_utils.get_valid_cuisine(value)
if cuisine['is_valid']:
self.cuisine_id = cuisine["cuisine_id"]
return value
else:
dispatcher.utter_template('utter_wrong_cuisine', tracker)
return None
def validate_cuisine(self, value: Text, dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> Optional[Text]:
"""Validate cuisine value."""
if value.lower() in self.cuisine_db():
# validation succeeded
return value
else:
dispatcher.utter_template('utter_wrong_cuisine', tracker)
# validation failed, set this slot to None, meaning the
# user will be asked for the slot again
return None
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List['Event']:
intent = tracker.latest_message['intent'].get('name')
events = self._get_events()
if not events:
dispatcher.utter_template("utter_no_community_event", tracker)
elif intent == 'ask_which_events':
self._utter_event_overview(dispatcher)
elif intent == 'ask_when_next_event':
self._utter_next_event(tracker, dispatcher)
return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
intent_name = tracker.latest_message['intent'].get('name')
entity_name = tracker.latest_message['entities']
print("value of intent " + str(intent_name))
print("value of entity " + str(entity_name))
if intent_name == "get_started":
dispatcher.utter_template("utter_payload", tracker)
return [UserUtteranceReverted()]
else:
message = "कृपया आप सही जानकारी प्रदान करें"
dispatcher.utter_message(message)
return [UserUtteranceReverted()]
def validate_age(
self,
value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> Optional[Text]:
"""Validate pain_scale value."""
if self.is_int(value) and int(value) >= 0:
return value
else:
dispatcher.utter_template("utter_erro_idade", tracker)
return None
def validate_pain_persistance(
self,
value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> Any:
"""Validate other_symptoms value."""
if value in self.pain_persistance_db():
return value
else:
dispatcher.utter_template("utter_erro_persistencia_dor", tracker)
# validation failed, set slot to None
return None
def run(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List:
intent = tracker.latest_message['intent'].get('name')
# retrieve the correct chitchat utterance dependent on the intent
if intent in ['ask_builder', 'ask_weather', 'ask_howdoing',
'ask_howold', 'ask_languagesbot', 'ask_restaurant',
'ask_time', 'ask_wherefrom', 'ask_whoami',
'handleinsult', 'telljoke', 'ask_whatismyname']:
dispatcher.utter_template('utter_' + intent, tracker)
return []
def validate_location(self,
value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> Optional[Text]:
location = zomato_utils.get_valid_location(value)
if location['is_valid']:
self.lat = location["latitude"]
self.lon = location["longitude"]
return value
else:
dispatcher.utter_template('utter_wrong_location', tracker)
return None
def validate_pain_scale(
self,
value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> Optional[Text]:
"""Validate pain_scale value."""
if self.is_int(value) and int(value) > 0:
return value
else:
dispatcher.utter_template("utter_erro_escala_de_dor", tracker)
# validation failed, set slot to None
return None
def validate_cancelled_licence_company_type(
self, value: Text, dispatcher: CollectingDispatcher,
tracker: Tracker, domain: Dict[Text, Any]) -> Optional[Text]:
"""Validate cancelled_licence_company_type"""
print("In cancelled_licence_company_type, val: {}".format(value))
if "محلي" in value or "law" in value:
return "law"
elif "فرع" in value or "branch" in value:
return "branch"
else:
dispatcher.utter_template(
'utter_cancelled_licence_company_not_supported', tracker)
# affirm/deny was picked up as T/F
return None
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
date = None
saved_time = None
num_persone = None
if any(tracker.get_latest_entity_values("num_persone")):
num = next(tracker.get_latest_entity_values("num_persone"))
if int(num) > 0:
num_persone = num
if any(tracker.get_latest_entity_values(
"time")): # check if Duckling got a time entity
date = next(tracker.get_latest_entity_values('time'), None)
time = next(tracker.get_latest_entity_values('time'), None)
time = time.split("T")[1].split(":")
time_to_evaluate = int(time[0])
num_persone_fix = 0 # used to handle the case where duckling extract num_persone as time
if num_persone is not None:
num_persone_fix = int(num_persone)
if time_to_evaluate != 0 and time_to_evaluate != num_persone_fix: # handle case with no time entered and case
# where duckling extract num_persone as time
if time_to_evaluate < 11:
time_to_evaluate += 12 # from 02:00 to 14:00
if (11 <= time_to_evaluate < 15) or (18 <= time_to_evaluate <
23):
saved_time = str(time_to_evaluate) + ":" + time[
1] + ":" + time[2] + ":" + time[3]
# from 2019-06-18T12:00:00.000+02:00 to 12:00:00.000+02:00
else:
dispatcher.utter_template("utter_orario_chiuso", tracker)
if datetime.strptime(date[:19], '%Y-%m-%dT%H:%M:%S').weekday(
) == 0: # check if it's monday (close day)
dispatcher.utter_template('utter_lunedi_chiuso', tracker)
else:
date = date.split("T")[0]
#save in the slot the information that we got
return [
SlotSet('data', date),
SlotSet('orario', saved_time),
SlotSet('num_persone', num_persone)
]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List['Event']:
# Fallback caused by TwoStageFallbackPolicy
if (len(tracker.events) >= 4 and tracker.events[-4].get('name')
== 'action_default_ask_affirmation'):
return [
SlotSet('feedback_value', 'negative'),
Form('feedback_form'),
FollowupAction('feedback_form')
]
# Fallback caused by Core
else:
dispatcher.utter_template('utter_default', tracker)
return [UserUtteranceReverted()]
