def submit(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
location_name = tracker.get_slot('location')
cuisine = tracker.get_slot('cuisine')
budget = tracker.get_slot('budget')
top_5_restaurants = []
if self.lat is not None and self.lon is not None and self.cuisine_id is not None and self.budget_type is not None:
top_5_restaurants = zomato_utils.get_top_restaurants_by_user_ratings(self.lat, self.lon, self.cuisine_id, self.budget_type)
response = "No restaurants found in {} serving {} cuisine in {} budget".format(location_name, cuisine, budget)
response_array = []
if len(top_5_restaurants) > 0:
index = 1
response = "Following are top 5 restaurants matching your preference in order of average user rating on zomato:\n\n"
for restaurant in top_5_restaurants:
response = response + "{}. {} in {} has been rated {}\n".format(index, restaurant['name'], restaurant['address'], restaurant['user_rating'])
index += 1
response_array = [SlotSet("lat", self.lat), SlotSet("lon", self.lon), SlotSet("cuisine_id", self.cuisine_id), SlotSet("budget_type", self.budget_type)]
dispatcher.utter_message(response)
return response_array
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]:
"""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 run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
facility_type = tracker.get_slot('facility_type')
healthcare_id = tracker.get_slot("facility_id")
full_path = _create_path(ENDPOINTS["base"], facility_type,
ENDPOINTS[facility_type]["id_query"],
healthcare_id)
results = requests.get(full_path).json()
selected = results[0]
if facility_type == FACILITY_TYPES["hospital"]["resource"]:
address = "{}, {}, {}".format(selected["address"].title(),
selected["zip_code"].title(),
selected["city"].title())
elif facility_type == FACILITY_TYPES["nursing_home"]["resource"]:
address = "{}, {}, {}".format(
selected["provider_address"].title(),
selected["provider_zip_code"].title(),
selected["provider_city"].title())
elif facility_type == FACILITY_TYPES["doctor"]["resource"]:
adr = selected["adr_ln_1"].title()
if "adr_ln_2" in selected.keys():
adr += " {}".format(selected["adr_ln_2"].title())
address = "{}, {}, {} {}\n Call {} to set up an appointment".format(
adr, selected["cty"].title(),
selected["st"], selected["zip"][:5].title(),
phone_format(selected["phn_numbr"]))
else:
address = "{}, {}, {}".format(selected["address"].title(),
selected["zip"].title(),
selected["city"].title())
return [
SlotSet("facility_address", address if results is not None else "")
]
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 run(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
facility_type = tracker.get_slot('facility_type')
healthcare_id = tracker.get_slot("facility_id")
full_path = _create_path(ENDPOINTS["base"], facility_type,
ENDPOINTS[facility_type]["id_query"],
healthcare_id)
results = requests.get(full_path).json()
if results:
selected = results[0]
if facility_type == FACILITY_TYPES["hospital"]["resource"]:
address = "{}, {}, {}".format(selected["address"].title(),
selected["zip_code"].title(),
selected["city"].title())
elif facility_type == FACILITY_TYPES["nursing_home"]["resource"]:
address = "{}, {}, {}".format(selected["provider_address"].title(),
selected["provider_zip_code"].title(),
selected["provider_city"].title())
else:
address = "{}, {}, {}".format(selected["address"].title(),
selected["zip"].title(),
selected["city"].title())
return [SlotSet("facility_address", address)]
else:
print("No address found. Most likely this action was executed "
"before the user choose a healthcare facility from the "
"provided list. "
"If this is a common problem in your dialogue flow,"
"using a form instead for this action might be appropriate.")
return [SlotSet("facility_address", "not found")]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List:
location = tracker.get_slot('location')
facility_type = tracker.get_slot('facility_type')
results = _find_facilities(location, facility_type)
button_name = _resolve_name(FACILITY_TYPES, facility_type)
if len(results) == 0:
dispatcher.utter_message(
"Sorry, we could not find a {} in {}.".format(
button_name, location))
return []
buttons = []
print("found {} facilities".format(len(results)))
for r in results:
if facility_type == FACILITY_TYPES["hospital"]["resource"]:
facility_id = r.get("provider_id")
name = r["hospital_name"]
elif facility_type == FACILITY_TYPES["nursing_home"]["resource"]:
facility_id = r["federal_provider_number"]
name = r["provider_name"]
elif facility_type == FACILITY_TYPES["doctor"]["resource"]:
facility_id = r["ind_enrl_id"]
name = "{} {}".format(r["frst_nm"], r["lst_nm"])
else:
facility_id = r["provider_number"]
name = r["provider_name"]
payload = "/inform{\"facility_id\":\"" + facility_id + "\"}"
buttons.append({
"title": "{}".format(name.title()),
"payload": payload
})
# limit number of buttons to 3 here for clear presentation purpose
if "near" in location:
location = "you"
dispatcher.utter_button_message(
"Here is a list of {} {}s near {}".format(len(buttons[:3]),
button_name, location),
buttons[:3],
button_type="custom")
# todo: note: button options are not working BUG in rasa_core
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 == '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 run(self, dispatcher, tracker: Tracker, domain):
# type: (Dispatcher, DialogueStateTracker, Domain) -> List[Event]
eventdate = tracker.get_slot('date')
query = {
"date": {
"$gte": datetime.now(tz=pytz.timezone('America/Santo_Domingo'))
}
}
# if eventdate:
# query = {"date": datetime.strptime(eventdate+"-"+str(datetime.now().year), '%B-%Y')}
projection = dict()
query["evento.asueto"] = "true"
projection["evento.nombre"] = 1
projection["date"] = 1
matches = list()
with MongoClient("mongodb://localhost:27017/") as client:
database = client["kb"]
collection = database["Calendarios"]
docs = collection.find(query, projection=projection)
if docs:
for doc in docs:
dia = doc['date'].strftime('%d de %B del %Y')
matches.append(doc['evento']['nombre'] + " " + dia + '\n')
dispatcher.utter_template('utter_ack_asuetos', tracker)
dispatcher.utter_message(matches.__str__())
return [SlotSet('asueto_count', docs.count())]
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))
else:
temp = tracker.get_latest_entity_values('PER')
aux = None
for i in temp:
if i.lower() != "hola":
aux = i
aux2 = next(tracker.get_latest_entity_values('persona'), None)
loc = next(tracker.get_latest_entity_values('LOC'), None)
misc = next(tracker.get_latest_entity_values('MISC'), None)
if aux is None and aux2 is not None:
return [SlotSet('persona', aux2.title())]
elif aux is not None and aux is not "Hola":
return [SlotSet('persona', aux.title())]
elif loc is not None:
return [SlotSet('persona', loc)]
elif misc is not None:
return [SlotSet('persona', misc)]
else:
dispatcher.utter_message("Dime cómo te llamas")
return []
return [SlotSet(slot, value) for slot, value in slot_values.items()]
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 submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Once required slots are filled, print buttons for found facilities"""
location = tracker.get_slot('location')
facility_type = tracker.get_slot('facility_type')
results = _find_facilities(location, facility_type)
button_name = _resolve_name(FACILITY_TYPES, facility_type)
if len(results) == 0:
dispatcher.utter_message(
"Sorry, we could not find a {} in {}.".format(
button_name, location.title()))
return []
buttons = []
# limit number of results to 3 for clear presentation purposes
for r in results[:3]:
if facility_type == FACILITY_TYPES["hospital"]["resource"]:
facility_id = r.get("provider_id")
name = r["hospital_name"]
elif facility_type == FACILITY_TYPES["nursing_home"]["resource"]:
facility_id = r["federal_provider_number"]
name = r["provider_name"]
else:
facility_id = r["provider_number"]
name = r["provider_name"]
payload = "/inform{\"facility_id\":\"" + facility_id + "\"}"
buttons.append({
"title": "{}".format(name.title()),
"payload": payload
})
if len(buttons) == 1:
message = "Here is a {} near you:".format(button_name)
else:
if button_name == "home health agency":
button_name = "home health agencie"
message = "Here are {} {}s near you:".format(
len(buttons), button_name)
# TODO: update rasa core version for configurable `button_type`
dispatcher.utter_button_message(message, buttons)
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 == 'cuisine':
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 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 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 == 'industry':
print("industry value.lower() " + value.lower())
if value.lower() not in self.industry_name_db():
dispatcher.utter_template('utter_wrong_industry', tracker)
# validation failed, set slot to None
slot_values[slot] = None
elif slot == 'degree_name':
print("degree_name value.lower() " + value.lower())
if value.lower() not in self.degree_name_db():
dispatcher.utter_template('utter_wrong_degree_name',
tracker)
# validation failed, set slot to None
slot_values[slot] = None
elif slot == 'career_level':
print("career_levely value.lower() " + value.lower())
if value.lower() not in self.career_level_db():
dispatcher.utter_template('utter_wrong_career_level',
tracker)
# validation failed, set slot to None
slot_values[slot] = None
elif slot == 'employment_type':
if value.lower() not in self.employment_type_db():
dispatcher.utter_template('utter_wrong_employment_type',
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 required_slots(tracker: Tracker) -> List[Text]:
if tracker.get_slot('property_type') == 'hotel':
return [
"city", "position", "num_people", "check_in", "check_out",
"stars", "property_type"
]
else:
return [
"city", "position", "num_people", "check_in", "check_out",
"property_type"
]
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
intent = tracker.latest_message['intent'].get('name')
if (intent == "afferma"):
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:]
prenotation_time_start = datetime.strptime(
prenotation_time, '%Y-%m-%dT%H:%M:%S.%f%z')
prenotation_time_end = prenotation_time_start + timedelta(
hours=2) # we assume that a reservation last 2 hours
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): # double check
insert_event(service, prenotation_time_start,
prenotation_time_end, number_of_people,
dispatcher)
dispatcher.utter_template("utter_confirmed", tracker)
return [SlotSet('conferma_prenotazione', True)]
else:
dispatcher.utter_message("Mi dispiace ma siamo pieni.")
return [
SlotSet('conferma_prenotazione', False),
SlotSet('available_seats', False)
]
elif intent == "nega":
dispatcher.utter_template('utter_not_confirmed', tracker)
return [SlotSet('conferma_prenotazione', False)]
def validate(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
slots_values = self.extract_other_slots(dispatcher, tracker, domain)
slot_to_fill = tracker.get_slot(REQUESTED_SLOT)
if slot_to_fill:
slots_values.update(
self.extract_requested_slot(dispatcher, tracker, domain))
if not slots_values:
raise ActionExecutionRejection(
self.name(), "Failed to validate slot {0} \
with action {1}".format(
slot_to_fill, self.name))
return [SlotSet(slot, value) for slot, value in slots_values.items()]
def run(self, dispatcher, tracker: Tracker, domain) -> list:
collection = Database('kb', 'ReqCursados').collection
matricula = tracker.get_slot("matricula")
if matricula:
pipeline = [
{
"$group": {
"_id": "$matricula",
"creditosAcumulados": {"$sum": '$creditos'}
}
},
]
result = [i for i in collection.aggregate(pipeline)][0]['creditosAcumulados']
dispatcher.utter_template("utter_creditos_acumulados", tracker, creditos=result)
return []
def submit(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Once we have an email, attempt to add it to the database"""
email = tracker.get_slot('email')
client = MailChimpAPI(config.mailchimp_api_key)
# if the email is already subscribed, this returns False
added_to_list = client.subscribe_user(config.mailchimp_list, email)
# utter submit template
if added_to_list:
dispatcher.utter_template('utter_confirmationemail', tracker)
else:
dispatcher.utter_template('utter_already_subscribed', tracker)
return []
def submit(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List[Dict]:
dispatcher.utter_message(
"❤️❤️❤️Thank you so much for showing your intrest in traveling with us"
)
insert_data(tracker.get_slot("travel_date"),
tracker.get_slot("travel_period"),
tracker.get_slot("trip_type"), tracker.get_slot("adults"),
tracker.get_slot("child"), tracker.get_slot("budget"),
tracker.get_slot("email"), tracker.get_slot("phno"))
return []
def run(self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List:
full_path = _create_path(ENDPOINTS["base"])
results = requests.get(full_path).json()
selected = results[0]
print("result:", selected)
print("que:", selected["question"])
question = selected["question"]
option1 = selected["option1"]
option2 = selected["option2"]
option3 = selected["option3"]
results_enq = tracker.get_slot('enquiry')
print("***result:", results_enq)
print("Hello Omkar. Counter class")
return []
def run(self, dispatcher, tracker: Tracker, domain):
# type: (Dispatcher, DialogueStateTracker, Domain) -> List[Event]
eventdate = tracker.get_slot('date')
query = {
"date": {"$gte": datetime.now(tz=pytz.timezone('America/Santo_Domingo'))}
}
# if eventdate:
# query = {"date": datetime.strptime(eventdate+"-"+str(datetime.now().year), '%B-%Y')}
projection = dict()
query["evento.asueto"] = "true"
projection["evento.nombre"] = 1
projection["date"] = 1
matches = list()
collection = Database('kb', 'Calendarios').collection
docs = collection.find(query, projection=projection)
if docs:
for doc in docs:
dia = doc['date'].strftime('%d de %B del %Y')
matches.append("- " + doc['evento']['nombre'] + " " + dia)
dispatcher.utter_template('utter_ack_asuetos', tracker)
dispatcher.utter_message("\n".join(matches))
return [SlotSet('asueto_count', docs.count())]
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()))
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 == 'account':
if value.lower() not in self.account_db():
dispatcher.utter_template('utter_wrong_account', tracker)
dispatcher.utter_message(
'Here are few Types which you can ' +
", ".join(self.account_db()))
# validation failed, set slot to None
slot_values[slot] = None
elif slot == 'accounttype':
if value.lower() not in self.accounttype():
dispatcher.utter_template('utter_wrong_account_type',
tracker)
dispatcher.utter_message(
'Here are few Types which you can ' +
", ".join(self.accounttype()))
# validation failed, set slot to None
slot_values[slot] = None
elif slot == 'producttype':
if value.lower() not in self.prodtype():
dispatcher.utter_template('utter_wrong_product_type',
tracker)
dispatcher.utter_message('you can enter one of these ' +
", ".join(self.prodtype()))
# validation failed, set slot to None
slot_values[slot] = None
elif slot == 'adjustmenttype':
if value.lower() not in self.adjtype():
dispatcher.utter_template('utter_wrong_adjustment_type',
tracker)
dispatcher.utter_message('below are the few options ' +
", ".join(self.adjtype()))
# 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 submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
libro = tracker.get_slot('libro')
autores = tracker.get_slot('autores')
intent = tracker.latest_message['intent'].get('name')
numIndexes = 0
numberofmorebooksearch = 0
if intent == "consulta_libros_kw":
if libro is not None:
dispatcher.utter_template("utter_libros_kw", tracker,
**tracker.slots)
numIndexes = 2
numberofmorebooksearch = 2
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
elif intent == "consulta_libros_autor":
if autores is not None:
dispatcher.utter_template("utter_libros_autor", tracker,
**tracker.slots)
numIndexes = 2
numberofmorebooksearch = 2
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
elif intent == "consulta_libro_titulo_autor":
if libro is not None and autores is not None:
dispatcher.utter_template("utter_libro_titulo_autor", tracker,
**tracker.slots)
numIndexes = 1
numberofmorebooksearch = 1
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
elif intent == "consulta_libro_kw":
if libro is not None:
dispatcher.utter_template("utter_libro_kw", tracker,
**tracker.slots)
numIndexes = 1
numberofmorebooksearch = 1
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
elif intent == "consulta_libros_titulo":
if libro is not None:
dispatcher.utter_template("utter_libros_titulo", tracker,
**tracker.slots)
numIndexes = 2
numberofmorebooksearch = 2
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
elif intent == "consulta_libro_titulo":
if libro is not None:
dispatcher.utter_template("utter_libro_titulo", tracker,
**tracker.slots)
numIndexes = 1
numberofmorebooksearch = 1
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
elif intent == "consulta_libro_autor":
if autores is not None:
dispatcher.utter_template("utter_libro_autor", tracker,
**tracker.slots)
numIndexes = 1
numberofmorebooksearch = 1
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
elif intent == "consulta_libros_titulo_autor":
if libro is not None and autores is not None:
dispatcher.utter_template("utter_libros_titulo_autor", tracker,
**tracker.slots)
numIndexes = 2
numberofmorebooksearch = 2
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
elif intent == "consulta_libros_kw_autor":
if libro is not None and autores is not None:
dispatcher.utter_template("utter_libros_kw_autor", tracker,
**tracker.slots)
numIndexes = 2
numberofmorebooksearch = 2
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
elif intent == "consulta_libro_kw_autor":
if libro is not None and autores is not None:
dispatcher.utter_template("utter_libro_kw_autor", tracker,
**tracker.slots)
numIndexes = 1
numberofmorebooksearch = 1
else:
dispatcher.utter_template("utter_especifica_libro", tracker,
**tracker.slots)
return [
SlotSet('searchindex', numIndexes),
SlotSet('numberofmorebooksearch', numberofmorebooksearch)
]
def required_slots(tracker: Tracker):
"""A list of required slots that the form has to fill"""
if tracker.get_slot('selectedflight'):
return ["username", "phonenumber", "aadhaar"]
return []
