def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
# choose random quiz
#max_id = quizzes.find().sort({_id:-1}).limit(1)["_id"]
rand_id = random.randint(0, 2)
quiz = quizzes.find_one({"_id": rand_id})
# print(quiz['fen'].split())
fen = Board(quiz['fen'].split())
if fen.isvalid:
fmt = "png"
if not os.path.isdir(OUTPUT):
# Handle if directory is not valid
os.mkdir(OUTPUT)
print("Creating new directory: {}".format(OUTPUT))
boardImg = DrawImage(fen, fmt, OUTPUT, "result")
boardImg.create()
boardImg.to_image()
print("Completed! File created in {}/{}.{}".format(
OUTPUT, "result", fmt))
else:
print("Invalid FEN. No Image file was generated.")
dispatcher.utter_template('utter_image',
tracker,
output="./result.png")
return []
def validate_outdoor_seating(
self,
value: Text,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> Any:
"""Validate outdoor_seating value."""
if isinstance(value, str):
if "out" in value:
# convert "out..." to True
return {"outdoor_seating": True}
elif "in" in value:
# convert "in..." to False
return {"outdoor_seating": False}
else:
dispatcher.utter_template("utter_wrong_outdoor_seating",
tracker)
# validation failed, set slot to None
return {"outdoor_seating": None}
else:
# affirm/deny was picked up as T/F
return {"outdoor_seating": value}
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
user_id = tracker.get_slot("user_id")
# Recebe rastreadores da aapi
trackers = requests.get(
f'http://localhost:10000/api/actions/{user_id}/trackers')
data = trackers.json()
tks = []
# Imprime sequencia de msg informando os dados da conta do usuario
is_activated = "ativa"
if (tracker.slots["is_actived"] == False):
is_activated = "inativa"
dispatcher.utter_template("utter_mostrar_dados", tracker)
dispatcher.utter_message(f"sua conta está {is_activated} \n")
dispatcher.utter_message("Seus rastreadores: \n")
for tk in data:
tks.append(tk['name'])
dispatcher.utter_message(
f"{tk['name']} - {tk['phone']} - imei- {tk['imei']}" + "\n")
return [SlotSet("rastreadores", {"tk": tks})]
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)
logger.info("validate, slot_values: {}".format(slot_values))
# extract requested slot
slot_to_fill = tracker.get_slot(REQUESTED_SLOT)
logger.info("validate, slot_to_fill: {}".format(slot_to_fill))
if slot_to_fill:
slot_values.update(
self.extract_requested_slot(dispatcher, tracker, domain))
if not slot_values:
dispatcher.utter_message(
"Sorry, I could not understand your response.")
for slot, value in slot_values.items():
if slot == 'penalty_location':
if value.lower() not in self.valid_penalty_location():
logger.debug("Invalid location type: {}".format(value))
dispatcher.utter_template('utter_invalid_penalty_area',
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[EventType]:
"""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]
try:
gdrive = GDriveService()
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 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"""
cur_int = tracker.latest_message.get("intent").get("name")
cur_ent = tracker.latest_message.get("entities")
if cur_int == "ask_weather" and not cur_ent:
dispatcher.utter_template("utter_confirm_weather_location",
tracker)
return []
elif cur_int == "deny":
dispatcher.utter_template("utter_ask_weather_location", tracker)
return []
msg = ("Weather in " + str(self.loc) + " is " + str(self.condition) +
" with " + str(self.degree) + " Celcius")
dispatcher.utter_message(msg)
return []
def run(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List["Event"]:
intent = tracker.latest_message["intent"].get("name")
# retrieve the correct chitchat utterance dependent on the intent
if intent in [
"ask_builder",
"ask_weather",
"ask_howdoing",
"ask_whatspossible",
"ask_time",
"ask_wherefrom",
"ask_whoami",
"handleinsult",
"telljoke",
"ask_whatismyname",
"ask_howbuilt",
"ask_whoisit",
"out_of_scope"
]:
dispatcher.utter_template("utter_" + intent, tracker)
dispatcher.utter_template("utter_default", tracker)
return [UserUtteranceReverted()]
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}
def run(self, dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
r = 'http://www.rochester.edu/sba/wp-content/uploads/2018/04/map-to-SBAC-1.jpg'
dispatcher.utter_template("utter_sorry", tracker, image=r)
return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
post_package = tracker.get_slot('post_package')
results = []
if post_package != None:
post_package = post_package.lower()
if post_package in [
'tin thuong', 'tin thường', 'tinthường', 'tinthuong'
]:
results.append('utter_vip0_info')
elif 'vip' in post_package:
if '1' in post_package:
results.append('utter_vip1_info')
elif '2' in post_package:
results.append('utter_vip2_info')
elif '3' in post_package:
results.append('utter_vip3_info')
if len(results) < 1:
results = [
'utter_vip0_info', 'utter_vip1_info', 'utter_vip2_info',
'utter_vip3_info'
]
for utter in results:
dispatcher.utter_template(utter, tracker)
return [SlotSet("post_package", None)]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
results = []
list_entity = tracker.get_last_event_for(
'user')["parse_data"]["entities"]
dispatcher.utter_message(
'Giữa các gói tin có sự khác nhau về mức độ ưu tiên hiển thị, màu và độ lớn của tiêu đề ạ.'
)
for entity in list_entity:
if entity['entity'] == 'post_package':
value = entity['value'].lower()
if value in [
'tin thuong', 'tin thường', 'tinthường', 'tinthuong'
]:
results.append('utter_vip0_info')
elif 'vip' in value:
if '1' in value:
results.append('utter_vip1_info')
elif '2' in value:
results.append('utter_vip2_info')
elif '3' in value:
results.append('utter_vip3_info')
if len(results) <= 1:
results = [
'utter_vip0_info', 'utter_vip1_info', 'utter_vip2_info',
'utter_vip3_info'
]
for utter in results:
dispatcher.utter_template(utter, tracker)
return [SlotSet("post_package", None)]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
Empid = tracker.get_slot("emp_id")
print(Empid)
# dispatcher.utter_message("Hi {}, Welcome to the Payroll Chatbot!, How may I help you?".format(Name))
dispatcher.utter_template("utter_capture_empid", tracker)
return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
language, script = get_language_and_script(tracker)
dispatcher.utter_template(
"{}_{}_utter_cheer_up".format(language, script), tracker)
return []
def run(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List[Dict[Text, Any]]:
"""
Executes this action. If the user ask a question about an attribute,
the knowledge base is queried for that attribute. Otherwise, if no
attribute was detected in the request or the user is talking about a new
object type, multiple objects of the requested type are returned from the
knowledge base.
Args:
dispatcher: the dispatcher
tracker: the tracker
domain: the domain
Returns: list of slots
"""
logger.info("action_query_attribute_of")
object_type = tracker.get_slot(SLOT_OBJECT_TYPE)
last_object_type = tracker.get_slot(SLOT_LAST_OBJECT_TYPE)
attribute = tracker.get_slot(SLOT_ATTRIBUTE)
new_request = object_type != last_object_type
if not object_type:
self.knowledge_base.default_object_type = 'doctor'
logger.info('query attribute attr:' + str(attribute) + ' new_req:' +
str(new_request))
return self._query_attribute(dispatcher, tracker)
dispatcher.utter_template("utter_ask_rephrase", tracker)
return []
def run(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List[Dict]:
dict_thongtin = {
"bến ninh kiều":
"Theo Wiki: Bến Ninh Kiều là một địa danh du lịch có từ lâu và hấp dẫn du khách bởi phong cảnh sông nước hữu tình và vị trí thuận lợi nhìn ra dòng sông Hậu. Từ lâu bến Ninh Kiều đã trở thành biểu tượng về nét đẹp thơ mộng bên bờ sông Hậu của cả Thành phố Cần Thơ, thu hút nhiều du khách đến tham quan và đi vào thơ ca.",
"chợ nổi cái răng":
"Theo Wiki: Chợ nổi Cái Răng là chợ nổi chuyên trao đổi, mua bán nông sản, các loại trái cây, hàng hóa, thực phẩm, ăn uống ở trên sông và là điểm tham quan đặc sắc của quận Cái Răng, thành phố Cần Thơ",
"nhà cổ bình thuỷ":
"Bằng giá trị kiến trúc, lịch sử của mình, nhà cổ Bình Thủy đã được công nhận là “di tích nghệ thuật cấp quốc gia”, ngày càng thu hút nhiều khách đến thăm cũng như các đoàn làm phim về mượn bối cảnh cho những thước phim của mình.",
"chùa ông":
"Theo Wiki: Chùa Ông (Cần Thơ), tên gốc là Quảng Triệu Hội Quán (chữ Hán: 廣肇會館；广肇会馆). Đây là một ngôi chùa của người Hoa gốc Quảng Đông tại Cần Thơ, và là một di tích lịch sử cấp quốc gia kể từ năm 1993.",
"vườn cây mỹ khánh":
"Đặt chân tới vườn trái cây này thì bạn sẽ được tham quan hơn 20 giống cây trồng khác nhau sẽ cho bạn một trải nghiệm đặc biệt.",
"chợ đêm":
"Ở đây có bán rất nhiều món ngon, trong đó có những món đặc trưng của miền Tây mà tiêu biểu là những món chè"
}
if any(tracker.get_latest_entity_values("thong_tin")):
# entity was picked up, validate slot
thongtin = tracker.get_slot("thong_tin")
ask = dict_thongtin[thongtin]
dispatcher.utter_template("utter_thongtin",
tracker,
thong_tin=thongtin,
tt_thongtin=ask)
else:
# no entity was picked up, we want to ask again
dispatcher.utter_template("utter_no_thongtin", tracker)
return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]):
city = tracker.latest_message['text']
temp = int(Weather(city)['temp'] - 273)
dispatcher.utter_template("utter_temp", tracker, temp=temp)
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker, domain):
message = (tracker.latest_message)['text']
sent = [i for i in message.split(' ')]
words = ["wtf",
"WTF",
"what the f**k",
"what the f**k",
"f*uck",
"f*uck you",
"f****r",
"You suck",
"I hate you",
"idiot",
"stfu",
"shut the f*** up",
"f*uk",
"f**k",
"f**k",
"wtf?",
"wtf bot",
]
flag = 0
for j in sent:
if j in words:
flag = 1
if flag==1:
dispatcher.utter_template('utter_out_of_context',tracker)
else:
dispatcher.utter_template('utter_greet',tracker)
dispatcher.utter_template('utter_start',tracker)
return [Restarted()]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
intents = ['greet', 'goodbye', 'affirm', 'deny', 'open_question','what_is_covid', 'what_symptoms',
'how_spread',
'how_spread_air',
'tf_transmitted_person_no_sy',
'tf_transmitted_person_feces',
'what_todo_protect',
'should_worry',
'how_risky',
'do_antibi_help',
'do_medici_exist',
'is_there_vaccine',
'should_use_mask',
'how_long_incubation',
'does_my_pet_get_infected',
'can_open_packages',
'want_know_more'
]
intent = tracker.latest_message["intent"].get("name")
if intent in intents:
dispatcher.utter_template("utter_response_"+intent, tracker)
return []
def validate_nomor_ktp(self, value: Text, dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> Optional[Dict]:
if tracker.latest_message.get('intent', {}).get('name') != 'cancel':
if re.search(_sixteen_digits, value) is False:
value = None
dispatcher.utter_template("utter_invalid_value",
tracker=tracker)
else:
sender_id = self.get_sender_id(tracker)
token = self.is_sender_id_token_exist(sender_id=sender_id,
tracker=tracker)
sum_contract_list = token.get_api_3(value)
data_user = DataUser(sender_id=sender_id,
token=token,
sum_contract_list=sum_contract_list,
index=0,
nomor_dipilih=[])
self.update_user_data(data_user=data_user)
if (not sum_contract_list) or (sum_contract_list is None):
value = None
dispatcher.utter_message(
"Maaf, kami tidak menemukan data berdasarkan nomor "
"KTP yang Anda masukan. Silakan ulang kembali ya")
return {_NOMOR_KTP: value}
def submit(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List[Dict]:
"""Definition of sumit."""
# "Define what the form has to do after all required slots are filled"
dispatcher.utter_message(template="utter_payment_processing ")
# utter submit template
dispatcher.utter_template("utter_submit", tracker)
# remind the limitation of air ambulance transport
if tracker.get_slot("client_medical_plane") is True:
dispatcher.utter_message(text="再次提醒貴賓：")
dispatcher.utter_message(template="utter_explain_medical_plane")
dispatcher.utter_message(template="utter_limitation_medical_plane")
dispatcher.utter_message(
template="utter_explain_asia_12_countries")
dispatcher.utter_message(
template="utter_payment_processed_successful ")
# return event
return []
def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
"""Define what the form has to do
after all required slots are filled"""
# utter submit template
ball_location = tracker.get_slot('ball_location')
reason_moved = tracker.get_slot('reason_moved')
who_moved = tracker.get_slot('who_moved')
ball_searching = tracker.get_slot('ball_searching')
logger.info(
"dispatch template, ball_location: \n{}, reason_moved: {}, who_moved: {}, ball_searching: {}"
.format(ball_location, reason_moved, who_moved, ball_searching))
lookup_str = (ball_location if ball_location else "") + "," + (
who_moved if who_moved else
"") + "," + (reason_moved if reason_moved else
"") + "," + (ball_searching if ball_searching else "")
logger.info("lookup_str: {}".format(lookup_str))
if lookup_str in ballmoved_dict:
utterance = ballmoved_dict[lookup_str]
else:
utterance = "utter_not_sure"
logger.info("utterance: {}".format(utterance))
dispatcher.utter_template(utterance, tracker)
# dispatcher.utter_template('utter_golfballmoved_slots', tracker)
return [
SlotSet("ball_location", None),
SlotSet("reason_moved", None),
SlotSet("who_moved", None),
SlotSet("ball_searching", None)
]
def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
# utter submit template
dispatcher.utter_template('utter_submit', tracker)
#dispatcher.utter_template('utter_transferMoney_values', tracker)
return []
def submit(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict]:
# utter submit template
first_name = tracker.get_slot('first_name')
middle_name = tracker.get_slot('middle_name')
last_name = tracker.get_slot('last_name')
email = tracker.get_slot('email')
phone = tracker.get_slot('phone')
logger.info("submit, first_name: {}, phone: {}".format(
first_name, phone))
#if penalty_location in relief_dict:
# utterance = relief_dict[penalty_location]
#else:
# utterance = "utter_not_sure"
#logger.info("utterance: {}".format(utterance))
logger.info("self._switch_intent: {}".format(self._switch_intent))
if self._switch_intent == True:
dispatcher.utter_message("you're switching intents...")
else:
dispatcher.utter_template("utter_customer_info", tracker)
# dispatcher.utter_template('utter_golfballmoved_slots', tracker)
return [
SlotSet("first_name", None),
SlotSet("middle_name", None),
SlotSet("last_name", None),
SlotSet("email", None),
SlotSet("phone", None)
]
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
city = tracker.get_slot("location")
temp = int(fetchWeatherinfo(city)['temp'] - 273)
dispatcher.utter_template("utter_temp", tracker, temp=temp, city=city)
return _set_emp_details_slot(tracker, response)
def run(self, dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
temp = casesapi()
dispatcher.utter_template("utter_cas", tracker, temp=temp)
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"""
survey = tracker.get_slot("survey")
debug = tracker.get_slot("debug")
logger.info(
"DynamicForm.submit, survey: {}, debug: {} (type: {})".format(
survey, debug, type(debug)
)
)
# if debug, utter debug info
if debug == "1":
msg = intentHistoryStr(tracker, 0, 4)
dispatcher.utter_message(msg) # send the message back to the user
# if debug, utter debug info
if survey == "1":
logger.info("Survey starting...")
dispatcher.utter_template("utter_ask_feedback", tracker)
# - utter_ask_feedback
# * feedback
# - action_feedback
return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
city = tracker.latest_message['text']
Temp = (Weather(city)['temp'] - 273)
dispatcher.utter_template('utter_temp', tracker, temp=Temp)
return []
def run(
self,
dispatcher: CollectingDispatcher,
tracker: Tracker,
domain: Dict[Text, Any],
) -> List[Dict]:
dict_vitri = {
"bến ninh kiều":
"Nằm ở: 38 Hai Bà Trưng, Tân An, Ninh Kiều, Cần Thơ",
"chợ nổi cái răng":
"Nằm ở: 46 Hai Bà Trưng, Lê Bình, Cái Răng, Cần Thơ",
"nhà cổ bình thuỷ":
"Nằm ở: 144 Bùi Hữu Nghĩa, Bình Thuỷ, Bình Thủy, Cần Thơ, Việt Nam",
"chùa ông":
"Nằm ở: 32, Hai Bà Trưng, Tân An, Ninh Kiều, Cần Thơ, Việt Nam",
"vườn cây mỹ khánh":
"Nằm ở: Mỹ Khánh, Phong Điền, Cần Thơ, Việt Nam",
"chợ đêm":
"Nằm ở: Hai Bà Trưng, Tân An, Ninh Kiều, Cần Thơ, Việt Nam"
}
if any(tracker.get_latest_entity_values("vi_tri")):
# entity was picked up, validate slot
vitri = tracker.get_slot("vi_tri")
ask = dict_vitri[vitri]
dispatcher.utter_template("utter_vitri",
tracker,
vi_tri=vitri,
tt_vitri=ask)
else:
# no entity was picked up, we want to ask again
dispatcher.utter_template("utter_no_vitri", 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"""
key= tracker.get_slot("key")
pageSize = '5' # Set the number to how many news articles you want to fetch
url = "https://newsapi.org/v2/everything?q=" + key + "&apiKey=" + NEWS_API_KEY + "&pageSize=" + pageSize
r = requests.get(url = url)
data = r.json() # extracting data in json format
data = data['articles']
dispatcher.utter_message("Here is some news I found!")
for i in range(len(data)):
output = data[i]['title'] + "\n" + data[i]['url'] + "\n"
dispatcher.utter_message(output)
dispatcher.utter_template("utter_confirm_if_service_is_correct", tracker)
# utter submit template
return []
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
Link = "https://www.ge.com/digital/need-technical-help"
# dispatcher.utter_message(text="Hello World!")
dispatcher.utter_template("utter_canthelp", tracker, link=Link)
return []
