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 []