def __init__(self):
# Create the loop and Flask app
self.loop = asyncio.get_event_loop()
self.flask = Flask(__name__, instance_relative_config=True)
self.flask.config.from_object(DefaultConfig)
# Create adapter.
# See https://aka.ms/about-bot-adapter to learn more about how bots work.
self.settings = BotFrameworkAdapterSettings(
self.flask.config["APP_ID"], self.flask.config["APP_PASSWORD"])
self.adapter = BotFrameworkAdapter(self.settings)
# Catch-all for errors.
async def on_error(adapter, context: TurnContext, error: Exception):
# This check writes out errors to console log .vs. app insights.
# NOTE: In production environment, you should consider logging this to Azure
# application insights.
print(f"\n [on_turn_error]: {error}", file=sys.stderr)
# Send a message to the user
error_message_text = "Sorry, it looks like something went wrong."
error_message = MessageFactory.text(error_message_text,
error_message_text,
InputHints.expecting_input)
await context.send_activity(error_message)
# pylint: disable=protected-access
if adapter._conversation_state:
# If state was defined, clear it.
await adapter._conversation_state.delete(context)
self.adapter.on_turn_error = MethodType(on_error, self.adapter)
# Create the main dialog
self.bot = MyBot()
async def process_activity(
channel_id: str, channel_data_tenant_id: str, conversation_tenant_id: str
):
activity = None
mock_claims = unittest.mock.create_autospec(ClaimsIdentity)
mock_credential_provider = unittest.mock.create_autospec(
BotFrameworkAdapterSettings
)
sut = BotFrameworkAdapter(mock_credential_provider)
async def aux_func(context):
nonlocal activity
activity = context.Activity
await sut.process_activity(
Activity(
channel_id=channel_id,
service_url="https://smba.trafficmanager.net/amer/",
channel_data={"tenant": {"id": channel_data_tenant_id}},
conversation=ConversationAccount(tenant_id=conversation_tenant_id),
),
mock_claims,
aux_func,
)
return activity
class BotConfig(AppConfig):
""" Bot initialization """
name = 'bots'
appConfig = config.DefaultConfig
SETTINGS = BotFrameworkAdapterSettings(appConfig.APP_ID, appConfig.APP_PASSWORD)
ADAPTER = BotFrameworkAdapter(SETTINGS)
LOOP = asyncio.get_event_loop()
# Create MemoryStorage, UserState and ConversationState
memory = MemoryStorage()
user_state = UserState(memory)
conversation_state = ConversationState(memory)
dialog = MainDialog(appConfig)
bot = DialogAndWelcomeBot(conversation_state, user_state, dialog)
async def on_error(self, context: TurnContext, error: Exception):
"""
Catch-all for errors.
This check writes out errors to console log
NOTE: In production environment, you should consider logging this to Azure
application insights.
"""
print(f'\n [on_turn_error]: { error }', file=sys.stderr)
# Send a message to the user
await context.send_activity('Oops. Something went wrong!')
# Clear out state
await self.conversation_state.delete(context)
def ready(self):
self.ADAPTER.on_turn_error = self.on_error
async def test_process_activity_for_forwarded_activity(self):
bot_app_id = "00000000-0000-0000-0000-000000000001"
skill_1_app_id = "00000000-0000-0000-0000-000000skill1"
identity = ClaimsIdentity(
claims={
AuthenticationConstants.AUDIENCE_CLAIM: skill_1_app_id,
AuthenticationConstants.APP_ID_CLAIM: bot_app_id,
AuthenticationConstants.VERSION_CLAIM: "1.0",
},
is_authenticated=True,
)
service_url = "https://root-bot.test.azurewebsites.net/"
async def callback(context: TurnContext):
TestBotFrameworkAdapter.get_creds_and_assert_values(
context, skill_1_app_id, bot_app_id, 1,
)
TestBotFrameworkAdapter.get_client_and_assert_values(
context, skill_1_app_id, bot_app_id, service_url, 1,
)
scope = context.turn_state[BotFrameworkAdapter.BOT_OAUTH_SCOPE_KEY]
assert bot_app_id == scope
settings = BotFrameworkAdapterSettings(bot_app_id)
sut = BotFrameworkAdapter(settings)
await sut.process_activity_with_identity(
Activity(channel_id="emulator", service_url=service_url, text="test",),
identity,
callback,
)
def do_POST(self):
body = self.rfile.read(int(self.headers['Content-Length']))
data = json.loads(str(body, 'utf-8'))
activity = Activity.deserialize(data)
self._adapter = BotFrameworkAdapter(APP_ID, APP_PASSWORD)
self._adapter.on_receive = self.on_receive
self._adapter.receive(self.headers.get("Authorization"), activity)
async def test_continue_conversation_with_audience(self):
mock_credential_provider = unittest.mock.create_autospec(CredentialProvider)
settings = BotFrameworkAdapterSettings(
app_id="bot_id", credential_provider=mock_credential_provider
)
adapter = BotFrameworkAdapter(settings)
skill_1_app_id = "00000000-0000-0000-0000-000000skill1"
skill_2_app_id = "00000000-0000-0000-0000-000000skill2"
skills_identity = ClaimsIdentity(
claims={
AuthenticationConstants.AUDIENCE_CLAIM: skill_1_app_id,
AuthenticationConstants.APP_ID_CLAIM: skill_2_app_id,
AuthenticationConstants.VERSION_CLAIM: "1.0",
},
is_authenticated=True,
)
skill_2_service_url = "https://skill2.com/api/skills/"
async def callback(context: TurnContext):
TestBotFrameworkAdapter.get_creds_and_assert_values(
context, skill_1_app_id, skill_2_app_id, 1,
)
TestBotFrameworkAdapter.get_client_and_assert_values(
context, skill_1_app_id, skill_2_app_id, skill_2_service_url, 1,
)
# pylint: disable=protected-access
client_cache = context.adapter._connector_client_cache
client = client_cache.get(
BotFrameworkAdapter.key_for_connector_client(
skill_2_service_url, skill_1_app_id, skill_2_app_id,
)
)
assert client
turn_state_client = context.turn_state.get(
BotFrameworkAdapter.BOT_CONNECTOR_CLIENT_KEY
)
assert turn_state_client
client_creds = turn_state_client.config.credentials
assert skill_1_app_id == client_creds.microsoft_app_id
assert skill_2_app_id == client_creds.oauth_scope
assert client.config.base_url == turn_state_client.config.base_url
scope = context.turn_state[BotFrameworkAdapter.BOT_OAUTH_SCOPE_KEY]
assert skill_2_app_id == scope
refs = ConversationReference(service_url=skill_2_service_url)
await adapter.continue_conversation(
refs, callback, claims_identity=skills_identity, audience=skill_2_app_id
)
def __init__(self, config, opsdroid=None):
"""Create the connector."""
self.name = config.get("name", "teams")
self.config = config
self.default_target = None # Teams has no default room
self.opsdroid = opsdroid
self.app_id = self.config.get("app-id", "abc123")
self.app_password = self.config.get("password", "")
self.adapter = BotFrameworkAdapter(
BotFrameworkAdapterSettings(self.app_id, self.app_password))
self.conversation_references = {}
self.service_endpoints = {}
async def __process_activity_creates_correct_creds_and_client(
self,
bot_app_id: str,
expected_caller_id: str,
channel_service: str,
expected_scope: str,
expected_app_credentials_count: int,
expected_client_credentials_count: int,
):
identity = ClaimsIdentity({}, True)
if bot_app_id:
identity.claims = {
AuthenticationConstants.AUDIENCE_CLAIM: bot_app_id,
AuthenticationConstants.APP_ID_CLAIM: bot_app_id,
AuthenticationConstants.VERSION_CLAIM: "1.0",
}
credential_provider = SimpleCredentialProvider(bot_app_id, None)
service_url = "https://smba.trafficmanager.net/amer/"
async def callback(context: TurnContext):
TestBotFrameworkAdapter.get_creds_and_assert_values(
context,
bot_app_id,
expected_scope,
expected_app_credentials_count,
)
TestBotFrameworkAdapter.get_client_and_assert_values(
context,
bot_app_id,
expected_scope,
service_url,
expected_client_credentials_count,
)
assert context.activity.caller_id == expected_caller_id
settings = BotFrameworkAdapterSettings(
bot_app_id,
credential_provider=credential_provider,
channel_provider=SimpleChannelProvider(channel_service),
)
sut = BotFrameworkAdapter(settings)
await sut.process_activity_with_identity(
Activity(
channel_id="emulator",
service_url=service_url,
text="test",
),
identity,
callback,
)
def init():
global LOOP
global ADAPTER
global BOT
app_id = "XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
app_password = "******"
settings = BotFrameworkAdapterSettings(app_id=app_id,
app_password=app_password)
ADAPTER = BotFrameworkAdapter(settings)
LOOP = asyncio.get_event_loop()
BOT = EchoBot()
async def test_process_activity_creates_correct_creds_and_client(self):
bot_app_id = "00000000-0000-0000-0000-000000000001"
identity = ClaimsIdentity(
claims={
AuthenticationConstants.AUDIENCE_CLAIM: bot_app_id,
AuthenticationConstants.APP_ID_CLAIM: bot_app_id,
AuthenticationConstants.VERSION_CLAIM: "1.0",
},
is_authenticated=True,
)
service_url = "https://smba.trafficmanager.net/amer/"
async def callback(context: TurnContext):
TestBotFrameworkAdapter.get_creds_and_assert_values(
context,
bot_app_id,
AuthenticationConstants.TO_CHANNEL_FROM_BOT_OAUTH_SCOPE,
1,
)
TestBotFrameworkAdapter.get_client_and_assert_values(
context,
bot_app_id,
AuthenticationConstants.TO_CHANNEL_FROM_BOT_OAUTH_SCOPE,
service_url,
1,
)
scope = context.turn_state[BotFrameworkAdapter.BOT_OAUTH_SCOPE_KEY]
assert AuthenticationConstants.TO_CHANNEL_FROM_BOT_OAUTH_SCOPE == scope
settings = BotFrameworkAdapterSettings(bot_app_id)
sut = BotFrameworkAdapter(settings)
await sut.process_activity_with_identity(
Activity(
channel_id="emulator",
service_url=service_url,
text="test",
),
identity,
callback,
)
def __init__(self, bot, name, app_id=None, app_password=None):
"""Create a receiver behavior object which acts on bot
:param bot: Bot instance for this receiver to control
:type bot: :class:`sparkbot.SparkBot`
:param name: The MS Teams name of the bot in Microsoft Teams, which will be
removed from incoming messages before dispatch
:param app_id: The Microsoft App ID to authenticate as
:param app_password: The Microsoft App Password to authenticate with
If ``app_id`` and ``app_password`` are not passed, ``MICROSOFT_APP_ID`` and
``MICROSOFT_APP_PASSWORD`` from the environment will be used, respectively.
"""
if not app_id:
try:
app_id = environ["MICROSOFT_APP_ID"]
except KeyError:
raise KeyError(
"MICROSOFT_APP_ID not found in environment and not passed in msteams.create() call"
)
if not app_password:
try:
app_password = environ["MICROSOFT_APP_PASSWORD"]
except KeyError:
raise KeyError(
"MICROSOFT_APP_PASSWORD not found in environment and not passed in msteams.create() call"
)
settings = BotFrameworkAdapterSettings(app_id, app_password)
self.adapter = BotFrameworkAdapter(settings)
self.name = name
self.bot = bot
from botbuilder.schema import Activity, ActivityTypes
from botbuilder.core import (BotFrameworkAdapter, BotFrameworkAdapterSettings,
TurnContext, ConversationState, MemoryStorage,
UserState, CardFactory)
from bots import StateManagementBot
relative_path = os.path.abspath(os.path.dirname(__file__))
path = os.path.join(relative_path, "config.yaml")
with open(path, 'r') as ymlfile:
cfg = yaml.safe_load(ymlfile)
PORT = cfg['Settings']['Port']
SETTINGS = BotFrameworkAdapterSettings(cfg['Settings']['AppId'],
cfg['Settings']['AppPassword'])
ADAPTER = BotFrameworkAdapter(SETTINGS)
# Catch-all for errors.
async def on_error(context: TurnContext, error: Exception):
# This check writes out errors to console log
# NOTE: In production environment, you should consider logging this to Azure
# application insights.
print(f'\n [on_turn_error]: { error }', file=sys.stderr)
# Send a message to the user
await context.send_activity('Oops. Something went wrong!')
# Clear out state
await conversation_state.delete(context)
ADAPTER.on_turn_error = on_error
from flask import Flask, request, Response
from botbuilder.schema import Activity
from botbuilder.core import (BotFrameworkAdapter, BotFrameworkAdapterSettings,
ConversationState, UserState, MemoryStorage)
import asyncio
from bot import StateBot
from botbuilder.azure import CosmosDbConfig, CosmosDbStorage
app = Flask(__name__)
loop = asyncio.get_event_loop()
botadaptersettings = BotFrameworkAdapterSettings("", "")
botadapter = BotFrameworkAdapter(botadaptersettings)
memstore = MemoryStorage()
constate = ConversationState(memstore)
#userstate = UserState(memstore)
key = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
cosconfig = CosmosDbConfig("https://*****:*****@app.route("/api/messages", methods=["POST"])
def messages():
if "application/json" in request.headers["content-type"]:
jsonmessage = request.json
from botbuilder.core import (BotFrameworkAdapterSettings, TurnContext,
BotFrameworkAdapter, ConversationState,
MemoryStorage)
from fastapi import FastAPI, Request, HTTPException
from botbuilder.schema import Activity, ActivityTypes
from bots import FAQBot
from config import DefaultConfig
import taiwan_bot_sheet
CONFIG = DefaultConfig()
# Create adapter.
# See https://aka.ms/about-bot-adapter to learn more about how bots work.
settings = BotFrameworkAdapterSettings(CONFIG.APP_ID, CONFIG.APP_PASSWORD)
adapter = BotFrameworkAdapter(settings)
# Catch-all for errors.
async def on_error(context: TurnContext, error: Exception):
# This check writes out errors to console log .vs. app insights.
# NOTE: In production environment, you should consider logging this to Azure
# application insights.
print(f"\n [on_turn_error] unhandled error: {error}", file=sys.stderr)
traceback.print_exc()
# Send a message to the user
await context.send_activity("The bot encountered an error or bug.")
await context.send_activity(
"To continue to run this bot, please fix the bot source code.")
# Send a trace activity if we're talking to the Bot Framework Emulator
from flask import Flask, request, Response
from botbuilder.core import BotFrameworkAdapter, BotFrameworkAdapterSettings, ConversationState, MemoryStorage
from botbuilder.schema import Activity
import asyncio
from luis.luisApp import LuisConnect
import os
from logger.logger import Log
app = Flask(__name__)
loop = asyncio.get_event_loop()
bot_settings = BotFrameworkAdapterSettings("", "")
bot_adapter = BotFrameworkAdapter(bot_settings)
#CON_MEMORY = ConversationState(MemoryStorage())
luis_bot_dialog = LuisConnect()
@app.route("/api/messages", methods=["POST"])
def messages():
if "application/json" in request.headers["content-type"]:
log = Log()
request_body = request.json
user_says = Activity().deserialize(request_body)
log.write_log(sessionID='TSRsession',
log_message="user says: " + str(user_says))
authorization_header = (request.headers["Authorization"]
if "Authorization" in request.headers else "")
async def call_user_fun(turncontext):
await luis_bot_dialog.on_turn(turncontext)
def test_should_return_channel_id_from_context_activity(self):
test_activity = Activity(channel_id=Channels.facebook)
test_context = TurnContext(BotFrameworkAdapter(settings=None), test_activity)
channel_id = Channel.get_channel_id(test_context)
self.assertEqual(Channels.facebook, channel_id)
def test_should_return_empty_from_context_activity_missing_channel(self):
test_activity = Activity(channel_id=None)
test_context = TurnContext(BotFrameworkAdapter(settings=None), test_activity)
channel_id = Channel.get_channel_id(test_context)
self.assertEqual("", channel_id)
from aiohttp.web import Request, Response, json_response
from botbuilder.core import BotFrameworkAdapterSettings, TurnContext, BotFrameworkAdapter, ConversationState, MemoryStorage, UserState
from botbuilder.core.integration import aiohttp_error_middleware
from botbuilder.schema import Activity, ActivityTypes
from src.dialogs import MainDialog
# from src.nlu import NLU
from src import Bot
from config import Config
# Load the config and create the bot
config = Config()
# Init a Bot adapter https://aka.ms/about-bot-adapter
settings = BotFrameworkAdapterSettings(config.APP_ID, config.APP_PASSWORD)
ADAPTER = BotFrameworkAdapter(settings)
# Catch-all for errors
async def on_error(context: TurnContext, error_: Exception):
"""
Catch-all functions to write out errors on console log.
NOTE: In production environment, logging should be done
to Azure application insights.
"""
# Print the error into the logs
print(f"\n [on_turn_error] unhandled error: {error_}", file=sys.stderr)
traceback.print_exc()
# Send a message to the user
async def test_continue_conversation_without_audience(self):
mock_credential_provider = unittest.mock.create_autospec(CredentialProvider)
settings = BotFrameworkAdapterSettings(
app_id="bot_id", credential_provider=mock_credential_provider
)
adapter = BotFrameworkAdapter(settings)
skill_1_app_id = "00000000-0000-0000-0000-000000skill1"
skill_2_app_id = "00000000-0000-0000-0000-000000skill2"
skills_identity = ClaimsIdentity(
claims={
AuthenticationConstants.AUDIENCE_CLAIM: skill_1_app_id,
AuthenticationConstants.APP_ID_CLAIM: skill_2_app_id,
AuthenticationConstants.VERSION_CLAIM: "1.0",
},
is_authenticated=True,
)
channel_service_url = "https://smba.trafficmanager.net/amer/"
async def callback(context: TurnContext):
TestBotFrameworkAdapter.get_creds_and_assert_values(
context,
skill_1_app_id,
AuthenticationConstants.TO_CHANNEL_FROM_BOT_OAUTH_SCOPE,
1,
)
TestBotFrameworkAdapter.get_client_and_assert_values(
context,
skill_1_app_id,
AuthenticationConstants.TO_CHANNEL_FROM_BOT_OAUTH_SCOPE,
channel_service_url,
1,
)
# pylint: disable=protected-access
client_cache = context.adapter._connector_client_cache
client = client_cache.get(
BotFrameworkAdapter.key_for_connector_client(
channel_service_url,
skill_1_app_id,
AuthenticationConstants.TO_CHANNEL_FROM_BOT_OAUTH_SCOPE,
)
)
assert client
turn_state_client = context.turn_state.get(
BotFrameworkAdapter.BOT_CONNECTOR_CLIENT_KEY
)
assert turn_state_client
client_creds = turn_state_client.config.credentials
assert skill_1_app_id == client_creds.microsoft_app_id
assert (
AuthenticationConstants.TO_CHANNEL_FROM_BOT_OAUTH_SCOPE
== client_creds.oauth_scope
)
assert client.config.base_url == turn_state_client.config.base_url
scope = context.turn_state[BotFrameworkAdapter.BOT_OAUTH_SCOPE_KEY]
assert AuthenticationConstants.TO_CHANNEL_FROM_BOT_OAUTH_SCOPE == scope
# Ensure the serviceUrl was added to the trusted hosts
assert AppCredentials.is_trusted_service(channel_service_url)
refs = ConversationReference(service_url=channel_service_url)
# Ensure the serviceUrl is NOT in the trusted hosts
assert not AppCredentials.is_trusted_service(channel_service_url)
await adapter.continue_conversation(
refs, callback, claims_identity=skills_identity
)
