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