async def select_attachment_type_step(self, step_context: WaterfallStepContext):
# Create the PromptOptions from the skill configuration which contain the list of configured skills.
message_text = "What attachment type do you want?"
reprompt_message_text = (
"That was not a valid choice, please select a valid card type."
)
options = PromptOptions(
prompt=MessageFactory.text(
message_text, message_text, InputHints.expecting_input
),
retry_prompt=MessageFactory.text(
reprompt_message_text, reprompt_message_text, InputHints.expecting_input
),
choices=[Choice("Inline"), Choice("Internet")],
)
return await step_context.prompt(ChoicePrompt.__name__, options)
async def selection_step(self, step_context: WaterfallStepContext):
return await step_context.prompt(
ChoicePrompt.__name__,
PromptOptions(
prompt=MessageFactory.text(
"Please indicate what do you want to know, or choose done to exit."
),
choices=[
Choice("Covid-19 Stats"),
Choice("Covid-19 Social"),
Choice("Covid-19 Health"),
Choice("Covid-19 Donation"),
Choice('Covid-19 Places'),
Choice("Done")
],
),
)
async def exec_test(turn_context: TurnContext):
dialog_context = await dialogs.create_context(turn_context)
results: DialogTurnResult = await dialog_context.continue_dialog()
if results.status == DialogTurnStatus.Empty:
options = PromptOptions(
prompt=Activity(type=ActivityTypes.message,
text="Please choose a color."),
choices=_color_choices,
style=ListStyle.auto,
)
await dialog_context.prompt("prompt", options)
elif results.status == DialogTurnStatus.Complete:
selected_choice = results.result
await turn_context.send_activity(selected_choice.value)
await convo_state.save_changes(turn_context)
async def destination_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
"""
If a destination city has not been provided, prompt for one.
:param step_context:
:return DialogTurnResult:
"""
goiylehoi_details = step_context.options
if goiylehoi_details.hoatDong is None:
return await step_context.end_dialog()
else:
if goiylehoi_details.diaDiem is None:
message_text = "Bạn dự định du lịch lễ hội ở tỉnh nào của Việt Nam ?"
prompt_message = MessageFactory.text(
message_text, message_text, InputHints.expecting_input)
return await step_context.prompt(
TextPrompt.__name__, PromptOptions(prompt=prompt_message))
return await step_context.next(goiylehoi_details.diaDiem)
async def select_delivery_mode_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
# Create the PromptOptions with the delivery modes supported.
message = "What delivery mode would you like to use?"
reprompt_message = (
"That was not a valid choice, please select a valid delivery mode."
)
options = PromptOptions(
prompt=MessageFactory.text(message, message,
InputHints.expecting_input),
retry_prompt=MessageFactory.text(reprompt_message,
reprompt_message,
InputHints.expecting_input),
choices=[Choice("normal"),
Choice("expectReplies")],
)
return await step_context.prompt(
self.select_delivery_mode_step.__name__, options)
async def breakfast_step(
step_context: WaterfallStepContext) -> DialogTurnResult:
# Save the number of nights
step_context.values["duration"] = step_context.result
# Confirm people and duration
await step_context.context.send_activity(
MessageFactory.text(
f"Okay, so {step_context.values['people']} people for {step_context.values['duration']} nights"
))
# ConfirmPrompt - Is taking breakfast ?
return await step_context.prompt(
"IsTakingBreakfastPrompt",
PromptOptions(
prompt=MessageFactory.text("Will you be having breakfast?")),
)
async def intro_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
if not self._luis_recognizer.is_configured:
await step_context.context.send_activity(
MessageFactory.text(
"NOTE: LUIS is not configured. To enable all capabilities, add 'LuisAppId', 'LuisAPIKey' and "
"'LuisAPIHostName' to the appsettings.json file.",
input_hint=InputHints.ignoring_input,
))
return await step_context.next(None)
message_text = (str(step_context.options) if step_context.options else
"What can I help you with today?")
prompt_message = MessageFactory.text(message_text, message_text,
InputHints.expecting_input)
return await step_context.prompt(TextPrompt.__name__,
PromptOptions(prompt=prompt_message))
async def origin_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
"""
If an origin city has not been provided, prompt for one.
:param step_context:
:return DialogTurnResult:
"""
booking_details = step_context.options
# Capture the response to the previous step's prompt
booking_details.destination = step_context.result
if booking_details.origin is None:
message_text = "From what city will you be travelling?"
prompt_message = MessageFactory.text(message_text, message_text,
InputHints.expecting_input)
return await step_context.prompt(
TextPrompt.__name__, PromptOptions(prompt=prompt_message))
return await step_context.next(booking_details.origin)
async def exec_test(turn_context:TurnContext):
dialog_context = await dialogs.create_context(turn_context)
results = await dialog_context.continue_dialog()
if (results.status == DialogTurnStatus.Empty):
options = PromptOptions(
prompt = Activity(
type = ActivityTypes.message,
text = "What is your favorite web site?"
)
)
await dialog_context.prompt("urlprompt", options)
elif results.status == DialogTurnStatus.Complete:
reply = results.result
await turn_context.send_activity(reply)
await conv_state.save_changes(turn_context)
async def exec_test(turn_context: TurnContext):
dialog_context = await dialogs.create_context(turn_context)
results: DialogTurnResult = await dialog_context.continue_dialog(
)
if results.status == DialogTurnStatus.Empty:
options = PromptOptions(prompt=Activity(
type=ActivityTypes.message, text="Please confirm."))
await dialog_context.prompt("prompt", options)
elif results.status == DialogTurnStatus.Complete:
confirmed = results.result
if confirmed:
await turn_context.send_activity("true")
else:
await turn_context.send_activity("false")
await convo_state.save_changes(turn_context)
async def job_type_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
if step_context.result.value == "Ja":
print("[DEBUG] Recognized system cricital job claim")
return await step_context.begin_dialog(
ChoicePrompt.__name__,
PromptOptions(prompt=MessageFactory.text(
"Zu welcher systemkritischen Gruppe gehören Sie?"),
choices=[
"Polizei", "Feuerwehr", "RichterIn",
"Staatsanwälte", "Justizvollzug",
"Rettungsdienst", "THW",
"Katastrophenschutz", "Mediziner", "Pfleger",
"Apotheher", "**Keine**"
],
style=ListStyle.list_style))
else:
return await step_context.next(Choice("**Keine**"))
async def dates_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
"""Prompt a user to enter no more than 4 dates on which they want to get the reports.
Validates the user input and re-promts is the validation isn't passed.
Args:
step_context (WaterfallStepContext): the context for the current dialog turn
Returns:
DialogTurnResult: result of calling the prompt stack manipulation method.
Contains the users' response.
"""
selected = step_context.result.value
step_context.values["max"] = self.LAST_OPTION
if selected == self.DONE_OPTION:
return await step_context.end_dialog()
max_period = await self.client.get_latest(
channel=self.options_list[selected])
self._max_period = max_period[0:-4]
self._query = self.options_list[selected]
message = (
f"Введите максимум 4 периода через запятую в следующем формате: 2019Q1, 2019Q2 и т.п."
f"Для получения данных за полный год выбирайте четвертый квартал."
f"Чтобы получить только самый последний отчет, отправьте слово '{self.LAST_OPTION}' и только его"
f"(запрос вида '2018Q2, {self.LAST_OPTION}' не сработает). \n"
f"Последний доступный отчет: {self._max_period}. \n Чтобы завершить диалог, отправьте '{self.DONE_OPTION}'"
)
retry_message = (
f"Пожалуйста, введите данные в правильном формате и на дату не позднее последней доступной."
f"Напоминаю, последний доступный отчет: {self._max_period}\n\n"
f"Правильный формат данных: 2019Q1, 2019Q2.\n\nЧтобы завершить диалог, отправьте '{self.DONE_OPTION}'"
)
prompt_options = PromptOptions(
prompt=MessageFactory.text(message),
retry_prompt=MessageFactory.text(retry_message),
validations=self._max_period.replace(self._query, ""),
)
return await step_context.prompt('dates', options=prompt_options)
async def destination_step(
self, step_context: WaterfallStepContext
) -> DialogTurnResult:
"""
If a destination city has not been provided, prompt for one.
:param step_context:
:return DialogTurnResult:
"""
booking_details = step_context.options
if booking_details.destination is None:
message_text = "Where would you like to travel to?"
prompt_message = MessageFactory.text(
message_text, message_text, InputHints.expecting_input
)
return await step_context.prompt(
TextPrompt.__name__, PromptOptions(prompt=prompt_message)
)
return await step_context.next(booking_details.destination)
async def _select_skill_action_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
# Get the skill info based on the selected skill.
selected_skill_id = step_context.result.value
selected_skill = self._skills_config.SKILLS.get(selected_skill_id)
# Remember the skill selected by the user.
step_context.values[self._selected_skill_key] = selected_skill
# Create the PromptOptions with the actions supported by the selected skill.
message_text = f"Select an action # to send to **{selected_skill.id}** or just type in a message and it will be forwarded to the skill"
options = PromptOptions(
prompt=MessageFactory.text(message_text, message_text,
InputHints.expecting_input),
choices=self._get_skill_actions(selected_skill),
)
# Prompt the user to select a skill action.
return await step_context.prompt("SkillActionPrompt", options)
async def check_query_mobile_number(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
if (step_context.result != None):
step_context.values["PolicyNumber"] = step_context.result
if (step_context.options.mobile_number != None):
step_context.values[
"MobileNumber"] = step_context.options.mobile_number
return await step_context.next(None)
else:
return await step_context.prompt(
phone,
PromptOptions(
prompt=MessageFactory.text(
"Please provide your phone number."),
retry_prompt=MessageFactory.text(
"Enter a valid phone number."),
),
)
'''message_text = "Please provide your mobile number"
async def check_query_date_of_birth(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
if (step_context.result != None):
step_context.values["MobileNumber"] = step_context.result
if (step_context.options.date_of_birth != None):
step_context.values[
"DateOfBirth"] = step_context.options.date_of_birth
return await step_context.next(None)
else:
return await step_context.prompt(
date,
PromptOptions(
prompt=MessageFactory.text(
"Please provide your date of birth."),
retry_prompt=MessageFactory.text(
"Enter a valid date of birth."),
),
)
'''message_text = "Please provide your Date of Birth"
async def destination_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
"""
If a destination city has not been provided, prompt for one.
:param step_context:
:return DialogTurnResult:
"""
edit_booking_details = step_context.options
# Capture the response to the previous step's prompt
edit_booking_details.user_id = step_context.result
if edit_booking_details.destination is None:
message_text = "Where are you traveling to?"
prompt_message = MessageFactory.text(message_text, message_text,
InputHints.expecting_input)
return await step_context.prompt(
TextPrompt.__name__, PromptOptions(prompt=prompt_message))
return await step_context.next(edit_booking_details.destination)
async def intro_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
"""Initial prompt."""
if (not self._configuration.get("LUIS_APP_ID", "")
or not self._configuration.get("LUIS_API_KEY", "")
or not self._configuration.get("LUIS_API_HOST_NAME", "")):
await step_context.context.send_activity(
MessageFactory.text(
"NOTE: LUIS is not configured. To enable all"
" capabilities, add 'LUIS_APP_ID', 'LUIS_API_KEY' and 'LUIS_API_HOST_NAME'"
" to the config.py file."))
return await step_context.next(None)
return await step_context.prompt(
TextPrompt.__name__,
PromptOptions(
prompt=MessageFactory.text("What can I help you with today?")),
)
async def confirm_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
"""Confirm the information the user has provided."""
booking_details = step_context.options
# Capture the results of the previous step
booking_details.budget = step_context.result
message_text = (
f"Please confirm, I have you traveling to: { booking_details.destination } from: "
f"{ booking_details.origin } on: { booking_details.travel_date} return:{ booking_details.return_date}"
f" Budget: { booking_details.budget}.")
# prompt_message = MessageFactory.text(
# message_text, message_text, InputHints.expecting_input
# )
# Offer a YES/NO prompt.
return await step_context.prompt(
ConfirmPrompt.__name__,
PromptOptions(prompt=MessageFactory.text(message_text)))
async def selection_step(self, step_context: WaterfallStepContext):
self.new_country = False
step_context.values["country"] = step_context.result
return await step_context.prompt(
ChoicePrompt.__name__,
PromptOptions(
prompt=MessageFactory.text("Please indicate what do you want to know, or choose done to exit."),
choices=[Choice("Covid-19 Cases"),
Choice("Covid-19 Deaths"),
Choice("Covid-19 Tests"),
Choice('Covid-19 Twitter') ,
Choice('Covid-19 Meme') ,
Choice('Covid-19 Donation'),
Choice("Done")],
),
)
async def exec_test(turn_context: TurnContext) -> None:
dialogContext = await dialogs.create_context(turn_context)
results = await dialogContext.continue_dialog()
if results.status == DialogTurnStatus.Empty:
await dialogContext.begin_dialog(
'NumberPrompt',
PromptOptions(
prompt=MessageFactory.text('Enter quantity of cable')))
else:
if results.status == DialogTurnStatus.Complete:
numberResult = results.result
await turn_context.send_activity(
MessageFactory.text(
f"You asked me for '{numberResult}' meters of cable."
))
await conver_state.save_changes(turn_context)
async def intro_step(step_context: WaterfallStepContext) -> DialogTurnResult:
"""
Intro step. Triggered upon any interaction from the user to this bot.
"""
# Ask what to do
message = (
str(step_context.options)
if step_context.options
else "What can I help you with today?"
)
# TextPromp - How can I help you ?
return await step_context.prompt(
"ActPrompt",
PromptOptions(
prompt=MessageFactory.text(message)
),
)
async def ask_update_step(
self, step_context: WaterfallStepContext
) -> DialogTurnResult:
okr_details = step_context.options
if okr_details.okr_update_reply is None:
#message_text = self._action.get_random_utterance('msg_start_update')
message_text = self._action.get_okr_update_status(False) + '\n'
message_text = message_text + 'call API update OKR page with entity < ' + okr_details.get_okr_type() + '>'
prompt_message = MessageFactory.text(
message_text, message_text, InputHints.ignoring_input
)
return await step_context.prompt(
TextPrompt.__name__, PromptOptions(prompt=prompt_message)
)
return await step_context.next(okr_details.okr_update_reply)
async def choice_card_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
"""
1. Prompts the user if the user is not in the middle of a dialog.
2. Re-prompts the user when an invalid input is received.
"""
# Prompt the user with the configured PromptOptions.
return await step_context.prompt(
CARD_PROMPT,
PromptOptions(
prompt=MessageFactory.text(
"What card would you like to see? You can click or type the card name"
),
retry_prompt=MessageFactory.text(
"That was not a valid choice, please select a card or number from 1 "
"to 9."),
choices=self.get_choices(),
),
)
async def name_process_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
user_profile = await self.user_profile_accessor.get(
step_context.context, UserData)
if (user_profile.name != None and user_profile.user_greeted == True):
message_text = "What else can I do for you " + user_profile.name + " ?"
else:
user_profile.user_greeted = True
message_text = "Hi " + user_profile.name + ", How can I help you today?"
'''prompt_message = MessageFactory.text(message_text, message_text, InputHints.expecting_input)
await step_context.context.send_activity(message)'''
message = Activity(
type=ActivityTypes.message,
attachments=[self.create_adaptive_card(message_text)],
)
message.attachments[0].content['body'][0]['columns'][0]['items'][0][
'text'] = message_text
return await step_context.prompt(TextPrompt.__name__,
PromptOptions(prompt=message))
async def confirm_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
"""
Confirm the information the user has provided.
:param step_context:
:return DialogTurnResult:
"""
restaurant_details = step_context.options
# Capture the results of the previous step
restaurant_details.loc = step_context.result
message_text = (
f"So you're looking to eat {restaurant_details.food} in {restaurant_details.loc}, is that right?"
)
prompt_message = MessageFactory.text(message_text, message_text,
InputHints.expecting_input)
# Offer a YES/NO prompt.
return await step_context.prompt(ConfirmPrompt.__name__,
PromptOptions(prompt=prompt_message))
async def exec_test(turn_context: TurnContext) -> None:
dialog_context = await dialogs.create_context(turn_context)
results = await dialog_context.continue_dialog()
if results.status == DialogTurnStatus.Empty:
await dialog_context.begin_dialog(
"NumberPrompt",
PromptOptions(prompt=MessageFactory.text(
"How much money is in your gaming account?")),
)
else:
if results.status == DialogTurnStatus.Complete:
number_result = results.result
await turn_context.send_activity(
MessageFactory.text(
f"You say you have ${number_result} in your gaming account."
))
await conver_state.save_changes(turn_context)
async def exec_test(turn_context: TurnContext) -> None:
dialog_context: DialogContext = await dialogs.create_context(turn_context)
results: DialogTurnResult = await dialog_context.continue_dialog()
if results.status == DialogTurnStatus.Empty:
options = PromptOptions(
prompt=Activity(type=ActivityTypes.message, text="Enter a number."),
retry_prompt=Activity(
type=ActivityTypes.message, text="You must enter a number."
),
)
await dialog_context.prompt("NumberPrompt", options)
elif results.status == DialogTurnStatus.Complete:
number_result = results.result
await turn_context.send_activity(
MessageFactory.text(f"Bot received the number '{number_result}'.")
)
await convo_state.save_changes(turn_context)
async def orderid_step(
self, step_context: WaterfallStepContext) -> DialogTurnResult:
"""
If an origin city has not been provided, prompt for one.
:param step_context:
:return DialogTurnResult:
"""
ordering_details = step_context.options
# Capture the response to the previous step's prompt
ordering_details.email = step_context.result
if ordering_details.orderid is None:
message_text = "Please enter your order id."
prompt_message = MessageFactory.text(message_text, message_text,
InputHints.expecting_input)
return await step_context.prompt(
TextPrompt.__name__, PromptOptions(prompt=prompt_message))
# return await step_context.next(ordering_details.orderid)
user_input = ""
return await step_context.next(user_input)
async def exec_test(turn_context: TurnContext):
dialog_context = await dialogs.create_context(turn_context)
results = await dialog_context.continue_dialog()
if results.status == DialogTurnStatus.Empty:
options = PromptOptions(
prompt=Activity(
type=ActivityTypes.message, text="please add an attachment."
),
retry_prompt=Activity(
type=ActivityTypes.message, text="please try again."
),
)
await dialog_context.prompt("AttachmentPrompt", options)
elif results.status == DialogTurnStatus.Complete:
attachment = results.result[0]
content = MessageFactory.text(attachment.content)
await turn_context.send_activity(content)
await convo_state.save_changes(turn_context)
