async def test_emulator_msa_header_correct_app_id_and_service_url_should_validate( self): header = ( "Bearer " + MicrosoftAppCredentials("2cd87869-38a0-4182-9251-d056e8f0ac24", "2.30Vs3VQLKt974F").get_access_token()) credentials = SimpleCredentialProvider( "2cd87869-38a0-4182-9251-d056e8f0ac24", "") result = await JwtTokenValidation.validate_auth_header( header, credentials, "", "https://webchat.botframework.com/") assert result
def __handle_conversation_update_activity(self, activity): self.send_response(202) self.end_headers() if activity.members_added[0].id != activity.recipient.id: credentials = MicrosoftAppCredentials(APP_ID, APP_PASSWORD) reply = BotRequestHandler.__create_reply_activity( activity, 'Welcome to Summarize Bot') reply.attachments = [self.create_adaptive_card_attachment()] connector = ConnectorClient(credentials, base_url=reply.service_url) connector.conversations.send_to_conversation( reply.conversation.id, reply)
async def test_connector_auth_header_with_different_bot_app_id_should_not_validate( self): header = ( "Bearer " + MicrosoftAppCredentials("2cd87869-38a0-4182-9251-d056e8f0ac24", "2.30Vs3VQLKt974F").get_access_token()) credentials = SimpleCredentialProvider( "00000000-0000-0000-0000-000000000000", "") with pytest.raises(Exception) as excinfo: await JwtTokenValidation.validate_auth_header( header, credentials, "", "https://webchat.botframework.com/") assert "Unauthorized" in str(excinfo.value)
async def test_emulator_msa_header_and_no_credential_should_not_validate( self): header = ( "Bearer " + MicrosoftAppCredentials("2cd87869-38a0-4182-9251-d056e8f0ac24", "2.30Vs3VQLKt974F").get_access_token()) credentials = SimpleCredentialProvider( "00000000-0000-0000-0000-000000000000", "") with pytest.raises(Exception) as excinfo: await JwtTokenValidation.validate_auth_header( header, credentials, "", None) assert "Unauthorized" in excinfo
async def get_auth_token(): try: # pylint: disable=import-outside-toplevel from .app_creds_real import MICROSOFT_APP_ID, MICROSOFT_APP_PASSWORD # Define a "app_creds_real.py" file with your bot credentials as follows: # MICROSOFT_APP_ID = '...' # MICROSOFT_APP_PASSWORD = '******' return MicrosoftAppCredentials( MICROSOFT_APP_ID, MICROSOFT_APP_PASSWORD).get_access_token() except ImportError: return "STUB_ACCESS_TOKEN"
def __handle_message_activity(self, activity): self.send_response(200) self.end_headers() credentials = MicrosoftAppCredentials(APP_ID, APP_PASSWORD) connector = ConnectorClient(credentials, base_url=activity.service_url) userIntent = Analyze_User_Intent_LUIS(activity.text) response = Cafeteria_Response_Query(userIntent) # reply = BotRequestHandler.__create_reply_activity(activity, 'You said: %s' % activity.text) reply = BotRequestHandler.__create_reply_activity( activity, 'CafeteiaBot: %s' % response) connector.conversations.send_to_conversation(reply.conversation.id, reply)
async def test_channel_authentication_disabled_service_url_should_not_be_trusted( self, ): activity = Activity(service_url="https://webchat.botframework.com/") header = "" credentials = SimpleCredentialProvider("", "") await JwtTokenValidation.authenticate_request(activity, header, credentials) assert not MicrosoftAppCredentials.is_trusted_service( "https://webchat.botframework.com/" )
def __handle_message_activity(self, activity): self.send_response(200) self.end_headers() credentials = MicrosoftAppCredentials( MICROSOFT_CLIENT.get_microsoft_app_id(), MICROSOFT_CLIENT.get_microsoft_app_password()) connector = ConnectorClient(credentials, base_url=activity.service_url) response = MICROSOFT_CLIENT.ask_question(activity.text) reply = BotRequestHandler.__create_reply_activity(activity, response) connector.conversations.send_to_conversation(reply.conversation.id, reply)
def __handle_conversation_update_activity(self, activity): self.send_response(202) self.end_headers() if activity.members_added[0].id != activity.recipient.id: credentials = MicrosoftAppCredentials(APP_ID, APP_PASSWORD) reply = BotRequestHandler.__create_reply_activity( activity, 'Hello, welcome to Doctor Bot.\n' + 'If you are not feeling well, tell me whats wrong, ' + 'and I will try to help you out') connector = ConnectorClient(credentials, base_url=reply.service_url) connector.conversations.send_to_conversation( reply.conversation.id, reply)
async def test_channel_msa_header_from_user_specified_tenant(self): activity = Activity( service_url='https://smba.trafficmanager.net/amer-client-ss.msg/') header = 'Bearer ' + MicrosoftAppCredentials( '2cd87869-38a0-4182-9251-d056e8f0ac24', '2.30Vs3VQLKt974F', 'microsoft.com').get_access_token(True) credentials = SimpleCredentialProvider( '2cd87869-38a0-4182-9251-d056e8f0ac24', '') claims = await JwtTokenValidation.authenticate_request( activity, header, credentials) assert claims.get_claim_value( "tid") == '72f988bf-86f1-41af-91ab-2d7cd011db47'
def __handle_conversation_update_activity(self, activity): self.send_response(202) self.end_headers() if activity.members_added[0].id != activity.recipient.id: credentials = MicrosoftAppCredentials(APP_ID, APP_PASSWORD) Bot.init = True Bot.sub = False Bot.menu_opt = False Bot.query = False reply = Bot.__create_reply_activity(activity, WELCOME) connector = ConnectorClient(credentials, base_url=reply.service_url) connector.conversations.send_to_conversation( reply.conversation.id, reply)
def __init__(self, config, opsdroid): self.name = self.__class__.__name__ self.loop = asyncio.get_event_loop() self.config = config self.opsdroid = opsdroid self.endpoint = config.get("endpoint", ENDPOINT) self.app_id = config.get("app_id", APP_ID) self.app_pass = config.get("app_pass", APP_PASS) self.credentials = MicrosoftAppCredentials(self.app_id, self.app_pass) self.credential_provider = SimpleCredentialProvider( self.app_id, self.app_pass) self.authenticated = False self.counter = 0 self._queue = asyncio.Queue() # message queue self._closing = asyncio.Event()
async def test_channel_msa_header_Valid_service_url_should_be_trusted( self): activity = Activity( service_url='https://smba.trafficmanager.net/amer-client-ss.msg/') header = 'Bearer ' + await MicrosoftAppCredentials( '2cd87869-38a0-4182-9251-d056e8f0ac24', '2.30Vs3VQLKt974F').get_access_token() credentials = SimpleCredentialProvider( '2cd87869-38a0-4182-9251-d056e8f0ac24', '') await JwtTokenValidation.authenticate_request(activity, header, credentials) assert MicrosoftAppCredentials.is_trusted_service( 'https://smba.trafficmanager.net/amer-client-ss.msg/')
async def test_get_user_token_returns_null(self): adapter = TestAdapter() activity = Activity( channel_id="directline", from_property=ChannelAccount(id="testuser") ) turn_context = TurnContext(adapter, activity) token_response = await adapter.get_user_token(turn_context, "myConnection") assert not token_response oauth_app_credentials = MicrosoftAppCredentials(None, None) token_response = await adapter.get_user_token( turn_context, "myConnection", oauth_app_credentials=oauth_app_credentials ) assert not token_response
async def send_message(req: Request) -> Response: try: credentials = MicrosoftAppCredentials(CONFIG.APP_ID, CONFIG.APP_PASSWORD) client = ConnectorClient(credentials, 'https://smba.trafficmanager.net/fr/') teams_client = TeamsConnectorClient(credentials, 'https://smba.trafficmanager.net/fr/') teams_channels = teams_client.teams.get_teams_channels('19:[email protected]') general_channel = next(channel for channel in teams_channels.conversations if channel.name is None) conversation_parameters = ConversationParameters( is_group=True, channel_data={"channel": {"id": general_channel.id}}, activity=MessageFactory.content_url('https://picsum.photos/200/300', 'image/png'), ) client.conversations.create_conversation(conversation_parameters) return Response(status=HTTPStatus.OK) except Exception: traceback.print_exc()
def _get_or_create_connector_client( self, service_url: str, credentials: AppCredentials) -> ConnectorClient: if not credentials: credentials = MicrosoftAppCredentials.empty() # Get ConnectorClient from cache or create. client_key = BotFrameworkAdapter.key_for_connector_client( service_url, credentials.microsoft_app_id, credentials.oauth_scope) client = self._connector_client_cache.get(client_key) if not client: client = ConnectorClient(credentials, base_url=service_url) client.config.add_user_agent(USER_AGENT) self._connector_client_cache[client_key] = client return client
async def test_channel_msa_header_invalid_service_url_should_not_be_trusted( self): activity = Activity(service_url='https://webchat.botframework.com/') header = 'Bearer ' + await MicrosoftAppCredentials( '2cd87869-38a0-4182-9251-d056e8f0ac24', '2.30Vs3VQLKt974F').get_access_token() credentials = SimpleCredentialProvider( '7f74513e-6f96-4dbc-be9d-9a81fea22b88', '') with pytest.raises(Exception) as excinfo: await JwtTokenValidation.authenticate_request( activity, header, credentials) assert 'Unauthorized' in str(excinfo.value) assert not MicrosoftAppCredentials.is_trusted_service( 'https://webchat.botframework.com/')
def __handle_initial_activity( self, activity): # Initialization- Welcome msg, hotel info and pics Bot.init = False self.send_response(200) self.end_headers() credentials = MicrosoftAppCredentials(APP_ID, APP_PASSWORD) connector = ConnectorClient(credentials, base_url=activity.service_url) Bot.Name = activity.text locs = Bot.show_location() st = wlc + Bot.Name + ". \nPlease choose which city you prefer." reply = Bot.__create_reply_activity(activity, st, locs) connector.conversations.send_to_conversation(reply.conversation.id, reply)
def __init__(self, config: DefaultConfig): super(MainDialog, self).__init__(MainDialog.__name__) self.connection_name = config.CONNECTION_NAME self.add_dialog( WaterfallDialog(WaterfallDialog.__name__, [self.sign_in_step, self.show_token_response])) self.add_dialog( OAuthPrompt( OAuthPrompt.__name__, OAuthPromptSettings( connection_name=self.connection_name, text="Sign In to AAD", title="Sign In", oauth_app_credentials=MicrosoftAppCredentials( app_id=config.APP_ID, password=config.APP_PASSWORD))))
def __handle_conversation_update_activity(self, activity): self.send_response(202) self.end_headers() if len(activity.members_added): if activity.members_added[0].id != activity.recipient.id: credentials = MicrosoftAppCredentials( MICROSOFT_CLIENT.get_microsoft_app_id(), MICROSOFT_CLIENT.get_microsoft_app_password()) response = MICROSOFT_CLIENT.get_new_user_message() reply = BotRequestHandler.__create_reply_activity( activity, response) connector = ConnectorClient(credentials, base_url=reply.service_url) connector.conversations.send_to_conversation( reply.conversation.id, reply)
def __init__( # pylint: disable=super-init-not-called self, inspection_state: InspectionState, user_state: UserState = None, conversation_state: ConversationState = None, credentials: MicrosoftAppCredentials = None, ): self.inspection_state = inspection_state self.inspection_state_accessor = inspection_state.create_property( "InspectionSessionByStatus") self.user_state = user_state self.conversation_state = conversation_state self.credentials = MicrosoftAppCredentials( credentials.microsoft_app_id if credentials else "", credentials.microsoft_app_password if credentials else "", )
def _create_streaming_connector_client( self, activity: Activity, request_handler: StreamingRequestHandler) -> ConnectorClient: empty_credentials = (MicrosoftAppCredentials.empty() if self._channel_provider and self._channel_provider.is_government() else MicrosoftGovernmentAppCredentials.empty()) streaming_driver = StreamingHttpDriver(request_handler) config = BotFrameworkConnectorConfiguration( empty_credentials, activity.service_url, pipeline_type=AsyncBfPipeline, driver=streaming_driver, ) streaming_driver.config = config connector_client = ConnectorClient(None, custom_configuration=config) return connector_client
def __handle_conversation_update_activity(self, activity): """ Handle any conversation update (triggers when bot is added) :param activity: :return: """ self.send_response(202) self.end_headers() if activity.members_added[0].id != activity.recipient.id: # if any member is added credentials = MicrosoftAppCredentials(APP_ID, APP_PASSWORD) # reply with Welcome Message reply = ChatbotHandler.__create_reply_activity( activity, WELCOME_MSG) connector = ConnectorClient(credentials, base_url=reply.service_url) connector.conversations.send_to_conversation( reply.conversation.id, reply)
async def test_get_user_token_returns_token_with_magice_code(self): adapter = TestAdapter() connection_name = "myConnection" channel_id = "directline" user_id = "testUser" token = "abc123" magic_code = "888999" activity = Activity(channel_id=channel_id, from_property=ChannelAccount(id=user_id)) turn_context = TurnContext(adapter, activity) adapter.add_user_token(connection_name, channel_id, user_id, token, magic_code) # First no magic_code token_response = await adapter.get_user_token(turn_context, connection_name) assert not token_response # Can be retrieved with magic code token_response = await adapter.get_user_token(turn_context, connection_name, magic_code) assert token_response assert token == token_response.token assert connection_name == token_response.connection_name # Then can be retrieved without magic code token_response = await adapter.get_user_token(turn_context, connection_name) assert token_response assert token == token_response.token assert connection_name == token_response.connection_name # Then can be retrieved using customized AppCredentials oauth_app_credentials = MicrosoftAppCredentials(None, None) token_response = await adapter.get_user_token( turn_context, connection_name, oauth_app_credentials=oauth_app_credentials) assert token_response assert token == token_response.token assert connection_name == token_response.connection_name
async def __build_credentials(self, app_id: str, oauth_scope: str = None) -> AppCredentials: app_password = await self._credential_provider.get_app_password(app_id) if self._channel_provider.is_government(): return MicrosoftGovernmentAppCredentials( app_id, app_password, self.settings.channel_auth_tenant, scope=oauth_scope, ) return MicrosoftAppCredentials( app_id, app_password, self.settings.channel_auth_tenant, oauth_scope=oauth_scope, )
def __handle_message_activity(self, activity): """ Handle the messages. STATE used to collect APPID and APPKEY up front. All other messsages sent to LUIS for parsing. APPID and APPKEY specify the LUIS service called via REST. For example: https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/((APPID))?subscription-key=((APPKEY)) &verbose=true&timezoneOffset=0&q=((TEXT-FOR-LUIS-TO-PARSE """ BotRequestHandler.STATE+=1 ## POORMAN'S STATE TRACKING self.send_response(200) self.end_headers() credentials = MicrosoftAppCredentials(APPID, APPPASSWORD) connector = ConnectorClient(credentials, base_url=activity.service_url) LUIStext = '' ## FIRST, GET APPID if self.STATE==1: if activity.text: BotRequestHandler.LUISAPPID=activity.text reply = BotRequestHandler.__create_reply_activity(activity, "You entered application ID: %s\nNow, please input your subscription key (default: %s):" % (activity.text,self.LUISAPPKEY)) ## SECOND, GET APPKEY elif self.STATE==2: if activity.text: BotRequestHandler.LUISAPPKEY=activity.text reply = BotRequestHandler.__create_reply_activity(activity, "Great! You entered application key: %s\nNow, enter some text for the LUIS model to render:" % activity.text) ## THIRD AND ONWARDS: SEND TEXT TO LUIS AND REPORT LUIS RESPONSE TO THE USER else: try: CLIENT = LUISClient(self.LUISAPPID, self.LUISAPPKEY, True) res = CLIENT.predict(activity.text) while res.get_dialog() is not None and not res.get_dialog().is_finished(): TEXT = input('%s\n'%res.get_dialog().get_prompt()) res = CLIENT.reply(TEXT, res) LUIStext=self.__handle_LUIS_response(res) reply = BotRequestHandler.__create_reply_activity(activity, 'LUIS says: %s' % LUIStext) except Exception as exc: LUIStext=exc print("Error: %s" % exc) reply = BotRequestHandler.__create_reply_activity(activity, 'About %s, LUIS complains: %s' % (activity.text,LUIStext)) connector.conversations.send_to_conversation(reply.conversation.id, reply)
def __init__(self, settings: BotFrameworkAdapterSettings): """ Initializes a new instance of the :class:`BotFrameworkAdapter` class. :param settings: The settings to initialize the adapter :type settings: :class:`BotFrameworkAdapterSettings` """ super(BotFrameworkAdapter, self).__init__() self.settings = settings or BotFrameworkAdapterSettings("", "") self.settings.channel_service = self.settings.channel_service or os.environ.get( AuthenticationConstants.CHANNEL_SERVICE ) self.settings.open_id_metadata = ( self.settings.open_id_metadata or os.environ.get(AuthenticationConstants.BOT_OPEN_ID_METADATA_KEY) ) self._credentials = MicrosoftAppCredentials( self.settings.app_id, self.settings.app_password, self.settings.channel_auth_tenant, ) self._credential_provider = SimpleCredentialProvider( self.settings.app_id, self.settings.app_password ) self._is_emulating_oauth_cards = False if self.settings.open_id_metadata: ChannelValidation.open_id_metadata_endpoint = self.settings.open_id_metadata GovernmentChannelValidation.OPEN_ID_METADATA_ENDPOINT = ( self.settings.open_id_metadata ) if JwtTokenValidation.is_government(self.settings.channel_service): self._credentials.oauth_endpoint = ( GovernmentConstants.TO_CHANNEL_FROM_BOT_LOGIN_URL ) self._credentials.oauth_scope = ( GovernmentConstants.TO_CHANNEL_FROM_BOT_OAUTH_SCOPE ) self._connector_client_cache: Dict[str, ConnectorClient] = {}
def __handle_message_activity(self, activity: Activity): self.send_response(200) self.end_headers() credentials = MicrosoftAppCredentials(APP_ID, APP_PASSWORD) connector = ConnectorClient(credentials, base_url=activity.service_url) print('User says %s' % activity.text) activity.text = filterUserMention( activity.text) # def : group chat fix resp_text = chatbot_core.df_query( activity.text) #process query to dialog flow if resp_text is None: resp_text = 'There is no response from the Bot.' reply = ChatbotHandler.__create_reply_activity(activity, resp_text) # reply = BotRequestHandler.__create_reply_activity(activity, 'You said: %s' % activity.text) connector.conversations.send_to_conversation(reply.conversation.id, reply) print(activity)
async def create( self, service_url: str, audience: str # pylint: disable=unused-argument ) -> ConnectorClient: if not self._service_url: self._service_url = service_url elif service_url != self._service_url: raise RuntimeError( "This is a streaming scenario, all connectors from this factory must all be for the same url." ) # TODO: investigate if Driver and pipeline should be moved here streaming_driver = StreamingHttpDriver(self._request_handler) config = BotFrameworkConnectorConfiguration( MicrosoftAppCredentials.empty(), service_url, pipeline_type=AsyncBfPipeline, driver=streaming_driver, ) streaming_driver.config = config connector_client = ConnectorClient(None, custom_configuration=config) return connector_client
async def __get_app_credentials(self, app_id: str, oauth_scope: str) -> AppCredentials: if not app_id: return MicrosoftAppCredentials.empty() # get from the cache if it's there cache_key = BotFrameworkAdapter.key_for_app_credentials( app_id, oauth_scope) app_credentials = self._app_credential_map.get(cache_key) if app_credentials: return app_credentials # If app credentials were provided, use them as they are the preferred choice moving forward if self._credentials: self._app_credential_map[cache_key] = self._credentials return self._credentials # Credentials not found in cache, build them app_credentials = await self.__build_credentials(app_id, oauth_scope) # Cache the credentials for later use self._app_credential_map[cache_key] = app_credentials return app_credentials