def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: logger = logging.getLogger(__name__) logger.debug('DEFINE ACTION') logger.debug(tracker.current_state()) last_entities = tracker.current_state()['latest_message']['entities'] word = '' for raw_entity in last_entities: logger.debug(raw_entity) if raw_entity.get('entity', '') == "thing": word = raw_entity.get('value', '') if raw_entity.get('entity', '') == "place": word = raw_entity.get('value', '') if raw_entity.get('entity', '') == "person": word = raw_entity.get('value', '') site = tracker.current_state().get('sender_id') if len(word) > 0: publish('hermod/' + site + '/tts/say', {"text": "Looking now"}) publish('hermod/' + site + '/display/startwaiting', {}) result = self.lookup(word) if result and len(result) > 0: dispatcher.utter_message(text=word + ". " + result) # TODO send hermod/XX/display/url {'url':'https://en.wiktionary.org/wiki/'+word} else: dispatcher.utter_message(text="I can't find the topic " + word) else: dispatcher.utter_message( text="I didn't hear your question. Try again") publish('hermod/' + site + '/display/stopwaiting', {}) slotsets = [] return slotsets
async def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: # logger = logging.getLogger(__name__) # logger.debug('SPELL WORD') last_entities = tracker.current_state()['latest_message']['entities'] # logger.debug(last_entities) word = '' slotsets = [] site = tracker.current_state().get('sender_id') slots = tracker.current_state().get('slots') for slot in slots: if slot == "word": if not word or len(word) <= 0: word = slots[slot] for raw_entity in last_entities: # logger.debug(raw_entity) if raw_entity.get('entity', '') == "word": word = raw_entity.get('value', '') slotsets = [] if word and len(word) > 0: word_record = await find_word(word) if not word_record: # try fuzzy match word_record = await search_word(word) if word_record: word = word_record.get('word') slotsets.append(SlotSet('word', word)) letters = [] # say letters for letter in word: letters.append(letter.upper()) message = word + " is spelled " + ", ".join(letters) dispatcher.utter_message(text=message) # loop = asyncio.get_event_loop() await send_to_wikipedia(word, site) slotsets.append(FollowupAction('action_end')) else: dispatcher.utter_message(text="I don't know the word " + word + ". Try again") else: dispatcher.utter_message( text="I didn't hear the word you want to spell. Try again") return slotsets
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: logger.info("\n\naction_hello_deepchat") event_length = len(tracker.current_state()['events']) logger.info("Number of events:"+str(event_length)) my_text = tracker.current_state()["latest_input_channel"] + ": "+ tracker.current_state()["sender_id"] dispatcher.utter_message(text= my_text) logger.info("exit action_hello_deepchat") return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: logger = logging.getLogger(__name__) logger.debug('DEFINE ACTION') #logger.debug(CONFIG) logger.debug(tracker.current_state()) last_entities = tracker.current_state()['latest_message']['entities'] site = tracker.current_state().get('sender_id') word = '' for raw_entity in last_entities: logger.debug(raw_entity) if raw_entity.get('entity', '') == "word": word = raw_entity.get('value', '') if len(word) > 0: #dispatcher.utter_message(text=) publish('hermod/' + site + '/tts/say', {"text": "Looking now"}) publish('hermod/' + site + '/display/startwaiting', {}) result = self.lookup(word) if result and len(result.get('definition', '')) > 0: publish( 'hermod/' + site + '/display/show', { 'buttons': [{ "label": 'date', "text": 'what is the date' }, { "label": 'time', "nlu": 'ask_time' }, { "label": 'link', "frame": 'https://en.wiktionary.org/wiki/' + word }] }) publish('hermod/' + site + '/display/show', {'frame': 'https://en.wiktionary.org/wiki/' + word}) dispatcher.utter_message(text="The meaning of " + word + " is " + result.get('definition', '')) # TODO send hermod/XX/display/url else: dispatcher.utter_message(text="I can't find the word " + word) publish('hermod/' + site + '/display/stopwaiting', {}) else: dispatcher.utter_message( text="I didn't hear the word you want defined. Try again") slotsets = [] return slotsets
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: print("action get achievements") course_achieved = False currentCourse = [] courseId = 0 currentAchievements = [] current_state = tracker.current_state() token = current_state['sender_id'] currentCourseTitle = tracker.slots['current_course_title'] allCourses = tracker.slots['all_courses'] for course in allCourses: if currentCourseTitle in course['title']: courseId = course['id'] currentCourse = course break if courseId != 0: r = requests.get('https://learn.ki-campus.org/bridges/chatbot/my_courses/{0}/achievements'.format(courseId), headers={ "content-type": "application/json", "Authorization": 'Bearer {0}'.format(token), "Accept-Language": "de" }) status = r.status_code if status == 200: response = json.loads(r.content) currentAchievements = response for achievement in response: dispatcher.utter_message('{0}'.format(achievement['description'])) if achievement['achieved'] and not course_achieved: course_achieved = True return[SlotSet('current_course_achieved', course_achieved), SlotSet('current_course', currentCourse), SlotSet('current_achievements', currentAchievements)] else: dispatcher.utter_message('Es tut mir sehr leid! Ich konnte den Kurs, den du suchst, nicht finden. Bitte versuche es erneut, indem du mir den Kurstitel nennen.') return[SlotSet('current_course_achieved', course_achieved), SlotSet('current_course', currentCourse), SlotSet('current_achievements', currentAchievements)]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: try: slotState = tracker.current_state()["slots"] # get slot states dispatcher.utter_message( text="Here is a summary review of your conversation:") summarylist = [] # List to store filled slots for key, value in slotState.items(): # check if slot is filled if value: string = key + ": " + value + "<br>" summarylist.append(string) finalList = '\n'.join( summarylist ) # Generate string with newline for each slot item in list for bot utterance dispatcher.utter_message(text=finalList) except: dispatcher.utter_message(text="summary list generation error") return []
def extract_metadata_from_tracker(tracker: Tracker) -> Dict: events = tracker.current_state().get("events", []) user_events = [e for e in events if e.get("event", "") == "user"] if not user_events: return {} else: return user_events[-1].get("metadata", {})
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: sender_id = tracker.current_state()['sender_id'] if sender_id is None: sender_id = "rasa-shell" res = WatchStock.select().where(WatchStock.sender_id == sender_id) if len(res) == 0: dispatcher.utter_message(template="utter_inform_empty_list", ) return [] for item in res: result = RequestPrice.CurrentPrice(item.symbol) date = result[0][constants.DATE] time = result[0][constants.TIME] dispatcher.utter_message( template='utter_answer_price', time=time_format.TimeHelper.toDisplayText(date, time), symbol=item.symbol, basic_price=result[0][constants.PRICE_TYPE_BASIC], floor_price=result[0][constants.PRICE_TYPE_FLOOR], ceiling_price=result[0][constants.PRICE_TYPE_CEILING], high_price=result[0][constants.PRICE_TYPE_HIGH], low_price=result[0][constants.PRICE_TYPE_LOW], change=result[0][constants.PRICE_TYPE_AD_CHANGE], change_pct=result[0][constants.PRICE_TYPE_AD_CHANGE_PCT], change_symbol=display_text.DisplayHelper.numberToArrow( result[0][constants.PRICE_TYPE_AD_CHANGE])) dispatcher.utter_message(template="utter_more_info") hook.after_processed(tracker, "action_show_watching_list") return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: logger = logging.getLogger(__name__) last_entities = tracker.current_state()['latest_message']['entities'] answer = 0 entities = [] slotsets = [] for raw_entity in last_entities: if raw_entity.get('extractor') == 'DucklingHTTPExtractor': entity = raw_entity['value'] if (float(entity) - int(entity)) > 0: entities.append(float(entity)) else: entities.append(int(entity)) if len(entities) > 1: answer = entities[0] * entities[1] if (answer - int(answer)) == 0: answer = int(answer) dispatcher.utter_message(text=str(entities[0]) + " plus " + str(entities[1]) + " is " + str(answer)) slotsets.append(SlotSet("result", str(answer))) else: dispatcher.utter_message( text="I didn't hear two numbers. Please try again.") return slotsets
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) state = tracker.current_state() intent = state["latest_message"]["intent"] logger.info("validate, slot_values: {}, intent: \n{}".format( slot_values, intent)) #fallback = FallbackPolicy().nlu_threshold #logger.info("fallback: \n{}".format(fallback)) slot_to_fill = tracker.get_slot(REQUESTED_SLOT) logger.info("validate, slot_to_fill: {}, user text: {}".format( slot_to_fill, state["latest_message"]["text"])) if slot_to_fill: slot_values.update( self.extract_requested_slot(dispatcher, tracker, domain)) if not slot_values: if slot_to_fill in self.proper_noun_slots(): return [ SlotSet(slot_to_fill, state["latest_message"]["text"]) ] else: dispatcher.utter_message( "Sorry, I could not understand your response.") logger.info("validate, normal exit for slot {}".format(slot_to_fill)) return [SlotSet(slot, value) for slot, value in slot_values.items()]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: import sqlite3 import json state = tracker.current_state() sender_id = state["sender_id"] #"42613706c7444af4ac33a316d0dcc2a8" con = sqlite3.connect("patient_profile.db") c = con.cursor() sessions = list( c.execute( f'SELECT * FROM patient_profile WHERE patient_id="{sender_id}"' )) #returns = [] symptoms = None drugs = None if sessions: if sessions[-1][-2]: symptoms = json.loads(sessions[-1][-2]) if sessions[-1][-1]: drugs = json.loads(sessions[-1][-1]) con.close() results = [ SlotSet("old_symptoms", symptoms), SlotSet("old_drugs", drugs) ] if symptoms: results.append(FollowupAction(name='ask_symptom_develop')) return results
def validate_used_vip_duration( self, value: Text, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any], ) -> Dict[Text, Any]: requested_slot = tracker.current_state()['slots']['requested_slot'] if requested_slot != 'used_vip_duration': return {"used_vip_duration": tracker.get_slot('used_vip_duration')} _, _, _, used_days = convert_duration(value) buy_vip_duration = tracker.get_slot('buy_vip_duration') if buy_vip_duration is not None: _, _, _, bought_days = convert_duration(buy_vip_duration) if used_days > bought_days: dispatcher.utter_template( 'utter_request_valid_used_vip_duration', tracker) return {"used_vip_duration": None, "duration": None} if used_days < 1: dispatcher.utter_template('utter_request_valid_used_vip_duration', tracker) return {"duration": None, "used_vip_duration": None} return {"duration": None, "used_vip_duration": value}
async def run( self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any], ) -> List[EventType]: # the session should begin with a `session_started` event message_metadata = [] events = tracker.current_state()['events'] for e in events: if e['event'] == 'user' or e['event'] == 'session_started': message_metadata.append(e) meta = message_metadata[-1]["metadata"]["metadata"] meta_dict = ast.literal_eval(meta) per_id = meta_dict["id"] fname = meta_dict["first_name"] lname = meta_dict["last_name"] events = [SessionStarted()] dispatcher.utter_message(template="utter_iamabot") dispatcher.utter_message("Pleased to meet you, {}!".format(fname)) dispatcher.utter_message("How're you doing today?") # any slots that should be carried over should come after the # `session_started` event events.extend(self.fetch_slots(dispatcher, tracker)) # an `action_listen` should be added at the end as a user message follows events.append(ActionExecuted("action_listen")) return events
def fetch_slots(dispatcher: CollectingDispatcher, tracker: Tracker) -> List[EventType]: """Collect slots that contain the user's name and hobbies.""" slots = [] for key in ("Person_First_Name", "Person_Last_Name", "Person_ID", "Hobby1", "Hobby2", "Hobby3"): value = tracker.get_slot(key) if value is not None: slots.append(SlotSet(key=key, value=value)) if tracker.get_slot("Person_First_Name") is None or tracker.get_slot( "Person_Last_Name") is None or tracker.get_slot("Person_ID") is None: message_metadata = [] events = tracker.current_state()['events'] for e in events: if e['event'] == 'user' or e['event'] == 'session_started': message_metadata.append(e) meta = message_metadata[-1]["metadata"]["metadata"] meta_dict = ast.literal_eval(meta) print(meta_dict) per_id = meta_dict["id"] fname = meta_dict["first_name"] lname = meta_dict["last_name"] slots.append(SlotSet(key="Person_ID", value=str(per_id))) slots.append(SlotSet(key="Person_First_Name", value=fname)) slots.append(SlotSet(key="Person_Last_Name", value=lname)) if mongodataverify(str(per_id)) == 0: mongodataupdate(str(per_id), str(fname), str(lname)) elif mongodataverify(str(per_id)) == 1: hobby1, hobby2, hobby3 = mongohobbyretrieve(str(per_id)) if hobby1 is not None and hobby2 is not None and hobby3 is not None: slots.append(SlotSet(key="Hobby1", value=str(hobby1))) slots.append(SlotSet(key="Hobby2", value=str(hobby2))) slots.append(SlotSet(key="Hobby3", value=str(hobby3))) return slots
def run( self, dispatcher, tracker: Tracker, domain: "DomainDict", ) -> List[Dict[Text, Any]]: # Took from -> https://github.com/RasaHQ/rasa/issues/3050 # This is a Simpler way of doing this. Must be better better way to do same sender_id_ = tracker.current_state()['sender_id'] name_ = tracker.get_slot("name") mobile_number_ = tracker.get_slot("number") mail_ = tracker.get_slot('mail') if_inserted = 'New User Inserted Successfully...' try: conn = sqlite3.connect('test.db') conn.execute( "INSERT INTO rasa (ID,NAME,PHONE,MAIL) \ VALUES (?,?,?,?)", (sender_id_, name_, mobile_number_, mail_)) conn.commit() except Exception as e: if_inserted = 'Some Error Occured.. (User Already Registered...)' print(e) dispatcher.utter_message(template="utter_details_thanks", Name=name_, Mobile_number=mobile_number_, E_Mail=mail_, If_Inserted=if_inserted)
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: current_state = tracker.current_state() token = current_state['sender_id'] r = requests.get('https://learn.ki-campus.org/bridges/chatbot/my_courses', headers={ "content-type": "application/json", "Authorization": 'Bearer {0}'.format(token) }) status = r.status_code if status == 200: response = json.loads(r.content) if len(response) < 1: dispatcher.utter_message('Du bist derzeit in keinem Kursen eingeschrieben.') return [SlotSet('courses_available', False)] else: dispatcher.utter_message('Du bist derzeit in diesen Kursen eingeschrieben:') for course in response: title = course['title'] dispatcher.utter_message(title) return [SlotSet('all_courses', response), SlotSet('courses_available', True)] elif status == 401: # Status-Code 401 None dispatcher.utter_message('Du bist derzeit in keinem Kursen eingeschrieben.') return [SlotSet('courses_available', False)] else: return []
async def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: logger = logging.getLogger(__name__) logger.debug('ACTION_ image') slotsets = [] site = tracker.current_state().get('sender_id') await publish('hermod/'+site+'/tts/say',{"text":"Looking now"}) search_term = self.extract_entities(tracker,['thing','person','place','word']) if search_term and len(search_term) > 0: executor = concurrent.futures.ProcessPoolExecutor( max_workers=1, ) images = await asyncio.get_event_loop().run_in_executor(executor,search_unsplash,search_term) if (images and len(images) > 0): await publish('hermod/'+site+'/display/show',{'images':images}) else : await publish('hermod/'+site+'/display/show',{'images':[]}) dispatcher.utter_message(text="I couldn't find any pictures of "+search_term) await publish('hermod/'+site+'/display/show',{'question':'Show me a picture of a '+search_term}) #dispatcher.utter_message(text="Done") else: await publish('hermod/'+site+'/display/show',{'question':'Show me a picture of a '}) dispatcher.utter_message(text="I didn't hear that right. What did you want to see a picture of?") slotsets.append(SlotSet("hermod_force_continue", "true")) logger.debug('ACTION_ image') return slotsets
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain): recipe_url = tracker.latest_message['text'] print(recipe_url) global recipe_manager recipe_manager = RecipeManager(recipe_url) print(recipe_url) print(tracker.current_state()) print(tracker.current_slot_values()) return_slots = [] if is_url_valid(recipe_url): print("is valid") validity = True dispatcher.utter_message(text="Url {} is valid".format(recipe_url)) return_slots.append(SlotSet("recipe_valid", validity)) return_slots.append(SlotSet("step_num", 0)) else: validity = False print("aint valid") dispatcher.utter_message( text="Url {} is invalid".format(recipe_url)) return_slots.append(SlotSet("recipe_valid", validity)) return return_slots
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: userid = tracker.current_state()["sender_id"] #print(str(tracker.current_state())) try: #print("place slot: " + str(tracker.get_slot('place'))) old_place = tracker.get_slot('place') #print("old_place: " + str(old_place)) place = self.__querent.get_place_address(str(old_place)) except Exception: dispatcher.utter_message( "Uh oh, I probably made at mistake processing the location you entered, but you may try again :)" ) return [] duration = int( ast.literal_eval(tracker.get_slot('duration'))['additional_info'] ['normalized']['value'] / 60) #event_name = tracker.latest_message['text'] event_name = tracker.get_slot('event_name') if place: planner = ph.restore(self.__storage_path, userid) planner.add_event( Event(event_name, Event.EventType.UNSPECIFIC, duration=duration, place=place)) ph.store(self.__storage_path, userid, planner) (hours, minutes) = globals.to_hours(duration) if hours == 0: duration = str(minutes) + " minutes" elif minutes > 0: if hours > 1: duration = str(hours) + " hours and " + str( minutes) + " minutes" else: duration = str(hours) + " hour and " + str( minutes) + " minutes" else: if hours > 1: duration = str(hours) + " hours" else: duration = str(hours) + " hour" response = ("Alright. I'm planning the event " + event_name + " at " + place + " which will take " + str(duration) + ".") dispatcher.utter_message(response) else: dispatcher.utter_message("I'm sorry but I couldn't find \"" + old_place + "\" entered :(") return []
def run(dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: user_id = (tracker.current_state())["sender_id"] cust_name = next(tracker.get_latest_entity_values("cust_name"), None) cust_sex = next(tracker.get_latest_entity_values("cust_sex"), None) bot_position = "Mình" dispatcher.utter_message("here's what I found:") if (cust_sex is None): cust_sex = "Quý khách" if (cust_sex == "anh") | (cust_sex == "chị"): bot_position = "em" elif (cust_sex == "cô") | (cust_sex == "chú"): bot_position = "cháu" else: cust_sex = "bạn" bot_position = "mình" if not cust_name: #dispatcher.utter_template("utter_greet_name",tracker) return [] return [ SlotSet('cust_name', cust_name), SlotSet('cust_sex', cust_sex), SlotSet('bot_position', bot_position) ]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: stock_code = tracker.get_slot("stock_code") if stock_code is None: dispatcher.utter_message( template='utter_ask_particular_stock_name') return [] sender_id = tracker.current_state()['sender_id'] if sender_id is None: sender_id = "rasa-shell" res = WatchStock.select().where(WatchStock.sender_id == sender_id and WatchStock.symbol == stock_code) if len(res) == 0: dispatcher.utter_message( template="utter_remove_from_watch_list_fail", stock_code="stock_code") else: q = WatchStock.get(symbol=stock_code, sender_id=sender_id) q.delete_instance() dispatcher.utter_message( template="utter_remove_from_watch_list_success", stock_code=stock_code) dispatcher.utter_message(template="utter_ask_for_show_list", ) hook.after_processed(tracker, "action_remove_from_watching_list") return []
def submit( self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any], ) -> List[Dict]: userid = tracker.current_state()["sender_id"] place = str(tracker.get_slot("place")) time = ast.literal_eval(str(tracker.get_slot("time"))) time_start = iso8601.parse_date(str(time['from'])) time_end = iso8601.parse_date(str(time['to'])) planner = ph.restore(self.__storage_path, userid) planner.set_home(place) planner.set_planning_times( globals.to_minutes(time_start.hour, time_start.minute), globals.to_minutes(time_end.hour, time_end.minute)) ph.store(self.__storage_path, userid, planner) dispatcher.utter_message("Thank you! I have set your home location to " + place + " and will plan your day between " + time_start.strftime("%I:%M %p") + " and " + time_end.strftime("%I:%M %p") + ".") return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: # use tracker to get last events metadata sent from front-end # metadata includes longitude and latitude of user if allowed state = tracker.current_state() last_events = state.get("events") most_recent = max(last_events, key=lambda e: e['timestamp']) longitude = most_recent["metadata"]["longitude"] latitude = most_recent["metadata"]["latitude"] #read out banks from our bank_data.json file banks = pd.read_json("./actions/bank_data.json", encoding='utf-8')['bank'] #If latitude and longitude have been fetched the user has allowed for location if latitude is not None and longitude is not None: dispatcher.utter_template("utter_thanks_for_location", tracker) #print("Þú ert hér: {} {}".format(latitude, longitude)) sortedlist = sorted(banks, key=lambda d: distance(d['longitude'], d[ 'latitude'], longitude, latitude))[0] dispatcher.utter_message("Næsti banki við þig er í:") dispatcher.utter_message("{}, {}, {}".format( sortedlist["name"], sortedlist["google_location"], sortedlist["location"])) else: dispatcher.utter_message( "Þú hefur ekki leyft okkur að nálgast staðsetningu þína..") return []
def submit( self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any], ) -> List[Dict]: most_recent_state = tracker.current_state() sender_id = most_recent_state['sender_id'] phone_number = tracker.get_slot("phone_number") phone_number_converted = '+{}'.format(phone_number) sender_id_converted = '{}'.format(sender_id) #TODO: Check if user phone number exists in job DB phone_number = tracker.get_slot("phone_number") job_title = tracker.get_slot("job_title") # after phone number submission and previously applied for the same role, prompt this if has_already_applied(phone_number=int(phone_number), job_title=job_title): dispatcher.utter_message( template="utter_already_applied_for_this_job") # data = job_openings() # message = {"payload": "quickReplies", "data": data} # dispatcher.utter_message(text="These are the job openings we have right now.👇", json_message=message) return [ FollowupAction("action_show_job_openings"), AllSlotsReset() ] # after phone number submission and not previously applied for the same role, ask for email id else: ask_email = "Your 𝐞𝐦𝐚𝐢𝐥? <br> We'll use it to inform you in case you are selected 😊" dispatcher.utter_message(text=ask_email) return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: is_QA = get_user_property((tracker.current_state())["sender_id"], 'is_QA') if is_QA > 0: answer = call_api_question_answer(tracker.latest_message['text']) dispatcher.utter_message(answer) #set_user_property((tracker.current_state())["sender_id"], 'is_QA', is_QA - 1) return None txt = domain['templates']['utter_default'][1]['text'] + \ """.\nBạn có thể nói cho mình biết bạn đang "Tìm" \ sản phẩm như thế nào, "Sử dụng" vào mục đích gì, \ "Giới hạn" các tiêu chí tìm kiếm và "So sánh" các \ sản phẩm nào với nhau. Để kết thúc phiên tìm kiếm \ bạn vui lòng nói với Tizzie "Tôi chọn sản phẩm" nào nhé.""" response = [{ "type": "text", "data": { "content": txt, "speak": True, } }] print(json.dumps(response)) dispatcher.utter_message(json.dumps(response))
def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict]: txt = domain['templates']['utter_finish_profile_form'][1]['text'] user_name = tracker.get_slot('user_name') user_age = tracker.get_slot('user_age') user_gender = tracker.get_slot('user_gender') txt = txt.replace("{user_name}", user_name) user_id = (tracker.current_state())["sender_id"] gender = 0 if (user_gender.lower()).strip() == 'nam' else 1 age = convert_age(int(user_age)) print(user_id, gender, age) # collection = mongo_database['users'] # dict_user = {"_id":user_id, "name": user_name, "gender": gender, "age": age} # collection.insert_one(dict_user) response = [{ "type": "text", "data": { "content": txt, "speak": False, } }] print(json.dumps(response)) dispatcher.utter_message(json.dumps(response)) return []
async def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: logger = logging.getLogger(__name__) logger.debug('YT') #await publish('hermod/'+site+'/tts/say',{"text":"Looking now"}) slotsets = [] site = tracker.current_state().get('sender_id') search_term = self.extract_entities( tracker, ['thing', 'person', 'place', 'word']) logger.debug(search_term) #dispatcher.utter_message(text="search youtube") # TODO CHECK SLOT CLIENT FOR CAPABILITIES AND REPLY APPROPRIATELY #https://www.youtube.com/results?search_query=juggling if search_term and len(search_term) > 0: videoId = self.api_search(search_term) await publish( 'hermod/' + site + '/display/show', {'question': 'Search youtube for ' + str(search_term)}) await publish('hermod/' + site + '/display/show', {'youtube': videoId}) # dispatcher.utter_message(text="Done") else: await publish('hermod/' + site + '/display/show', {'question': 'Search youtube for '}) dispatcher.utter_message( text= "I didn't hear that right. What did you want to search youtube for ?" ) slotsets.append(SlotSet("hermod_force_continue", "true")) # await publish('hermod/'+site+'/display/show',{'question':'Remember that the '+attribute+' of '+thing+' is '+answer}) # await publish('hermod/'+site+'/display/show',{'buttons':[{"label":'Yes please',"text":'yes please'},{"label":'No thanks',"text":'No thanks'}]}) # await publish('hermod/'+site+'/display/show',{'question':'Spell the word '+word})dispatcher.utter_message(text="The "+attribute+" of "+thing+" is "+ result) return slotsets
async def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: user_id = tracker.current_state()["sender_id"] rate = tracker.latest_message['text'] id_evaluated_game = fetch_id_game_recommandation(user_id) save_user_evaluation(id_evaluated_game, user_id, rate) dispatcher.utter_template("utter_happy", tracker) return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: current_state = tracker.current_state() params_dict = { "key": CHITCHAT_KEY, "appid": 0, "msg": current_state["latest_message"]["text"] } request_result = requests.get(CHITCHAT_URL, params=params_dict).json() dispatcher.utter_message(request_result["content"])
async def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain: Dict[Text, Any]) -> List[Dict[Text, Any]]: user_id = tracker.current_state()["sender_id"] video_game = fetch_recommandation(user_id) dispatcher.utter_template("utter_give_recommandation", tracker, video_game=video_game) return []