Para configurar o SSO para uma habilidade ou um assistente digital no Microsoft Teams, você precisa criar um aplicativo do Azure AD. Esse aplicativo é além do aplicativo Azure AD que você já criou como parte da configuração do canal do Microsoft Teams.

Antes de começar, verifique se você tem:

• Uma conta do Azure com uma assinatura ativa.
• O ID do Aplicativo Microsoft para o bot que você configurou com seu canal do Microsoft Teams.
• Acesso de administrador ao portal do Azure.

Veja as etapas para criar um aplicativo Azure AD para SSO:

1. Criar um novo registro de aplicativo:
   1. Navegue até https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps/ApplicationsListBlade no portal do Azure.
   2. Clique em Novo Registro.
   3. Preencha o campo Nome.
   4. Na seção Tipos de conta suportados, selecione o botão de opção Contas em qualquer diretório organizacional (Qualquer diretório AD do Azure - Multitenant) e contas pessoais da Microsoft (por exemplo, Skype, Xbox).
   5. Clique em Registrar.

      Depois que o aplicativo for criado, você entrará na seção Visão Geral. O ID do Aplicativo (cliente) e o ID do Diretório (tenant) devem ser criados para o aplicativo.

2. Adicione uma configuração de plataforma web:
   1. Na navegação esquerda, selecione Autenticação.
   2. Em Configurações de plataforma, clique em Adicionar uma plataforma e selecione Web.
   3. Adicione um URI de redirecionamento usando o seguinte formato:

      <YOUR_Oracle-Digital-Assistant_URL>/connectors/v2/callback

   4. Clique em Configurar.
3. Crie um segredo do cliente:
   1. Na navegação esquerda, selecione Certificados e segredos.
   2. Clique em + Novo segredo do cliente, preencha os campos obrigatórios e clique em Adicionar.
   3. Copie o valor do segredo do cliente e guarde-o em um local seguro. Você precisará desse valor posteriormente.
4. Configure o token:
   1. Na navegação esquerda, selecione Configuração de token.
   2. Clique em + Adicionar reivindicação opcional.
   3. Para Tipo de token, selecione Acesso.
   4. Selecione estas reivindicações:
      • given_name
      • upn
      • email
   5. Clique em Adicionar.
   6. Selecione a opção Ativar o e-mail do Microsoft Graph, permissão de perfil (obrigatório para que as reivindicações apareçam no token) e clique em Adicionar.
   7. Na navegação esquerda, selecione Permissões de API.

      Você pode ver que três permissões foram criadas.

   8. Clique em + Adicionar uma Permissão e adicione User.ReadBasic.All.

      Você precisará disso para acessar as informações do perfil.

5. Defina o URI do ID do aplicativo:
   1. Na navegação esquerda, selecione Expor uma API.
   2. Clique no campo URI do ID do Aplicativo.
   3. Atualize o valor no formato:

      api://botid-<Microsoft_App_ID_for_your_bot>

      Observação
      
      Esse precisa ser o ID do aplicativo do bot, não o do APP SSO.
   4. Clique em + Adicionar um escopo.
   5. No painel que é aberto:
      • Defina access_as_user com o nome do Escopo.

        A parte do domínio do nome do escopo exibido logo abaixo do campo de texto deve corresponder automaticamente ao URI do ID do Aplicativo definido na etapa anterior, com /access_as_user adicionado ao final.

      • Defina Quem pode consentir?como Administradores e usuários.
   6. Preencha os campos para configurar os prompts de consentimento do administrador e do usuário com valores apropriados para o escopo access_as_user.

      Aqui estão algumas sugestões:

      • Título do consentimento do administrador: As equipes podem acessar o perfil do usuário.
      • Descrição do consentimento do administrador: Permite que as Equipes chamem as APIs web do aplicativo como usuário atual.
      • Título do consentimento do usuário: As equipes podem acessar o perfil do usuário e fazer solicitações em seu nome.
      • Descrição do consentimento do usuário: Permite que as Equipes chamem as APIs desse aplicativo com os mesmos direitos que você tem
   7. Certifique-se de que Estado esteja definido como Ativado.
   8. Na seção Aplicativos clientes autorizados, clique em + Adicionar um aplicativo cliente.
   9. Digite os seguintes IDs:
      • 1fec8e78-bce4-4aaf-ab1b-5451cc387264

        Este é o aplicativo móvel e de desktop das Equipes.

      • 5e3ce6c0-2b1f-4285-8d4b-75ee78787346

        Este é o aplicativo web das Equipes.

6. Atualize o manifesto:
   1. Na navegação esquerda, selecione Manifesto.
   2. Defina "acceptMappedClaims" como true.
   3. Defina "accessTokenAcceptedVersion" como 2.
   4. Clique em Salvar.
7. Conceda permissões de administrador de tenant ao aplicativo Azure AD.
   1. Na navegação esquerda, selecione Visão Geral.
   2. Copie o ID do Aplicativo (cliente), o ID do Diretório (tenant) e o URI do ID do Aplicativo e salve-os em um local conveniente.
   3. Em uma janela privada do browser, faça log-in na conta de administrador da Microsoft.
      O URL tem o seguinte formato:

       https://login.microsoftonline.com/<tenant-id>/adminconsent?client_id=<client-id>

      em que você substitui <tenant-id> pelo ID do Diretório (tenant) que você acabou de copiar e substitui <client-id> pelo ID do Aplicativo (cliente) que acabou de copiar.
8. Na caixa de diálogo Permissões solicitadas, verifique e aceite as permissões.

Atualize seu bot Microsoft com os detalhes de SSO configurados:

1. Abra o bot no Portal do Desenvolvedor de Equipes e abra o Editor de Manifestos.
2. Selecione a guia Informações básicas.
3. Role para baixo até o campo Application (client) ID e insira o ID do aplicativo (client).
4. Selecione a guia Sign-On Único.
5. No URI do ID do Aplicativo, adicione o URI do ID do aplicativo copiado anteriormente.
6. Na navegação esquerda, selecione Publicar na organização.

Agora você registrará o aplicativo Azure AD como serviço de autenticação no Oracle Digital Assistant.

1. Em outra janela ou guia do browser, abra o Digital Assistant, expanda Definições no menu esquerdo e selecione Serviços de Autenticação.

2. Clique em + Serviço.
3. Na caixa de diálogo Novo Serviço de Autenticação, digite estes valores:
   • Provedor de Identidades: Microsoft Identify Platform
   • Nome: Um nome para identificar o serviço de autenticação.
   • URL de Ponto Final do Token: O URL do provedor de identidades para solicitar tokens de acesso. Uso:

     https://login.microsoftonline.com/<Azure-Active-Directory-TenantID>/oauth2/v2.0/token

   • Ponto Final de Autorização: O URL do IDP da página na qual os usuários fazem a autenticação informando seus nomes de usuário e senhas. Uso:

     https://login.microsoftonline.com/<Azure-Active-Directory-TenantID>/oauth2/v2.0/authorize

   • ID e Segredo do Cliente: O ID e o segredo do cliente para o aplicativo Azure AD (Cliente OAuth) que foi registrado. Use o ID e o segredo do aplicativo.
   • Escopo: <Application(client)_ID_for_your_bot>/access_as_user
   • Reivindicação do Sujeito: A reivindicação do perfil de token de acesso a ser usada para identificar o usuário. Use e-mail.

Em habilidades que precisam de autenticação de SSO, incorpore o componente OAuth 2.0 Account Link no fluxo de caixas de diálogo para tratar a autenticação por meio do serviço de autenticação. Nesse componente, certifique-se de definir a propriedade enableSingleSignOn como true. (Para fluxos de caixas de diálogo baseados em YAML, o componente é chamado System.OAuth2AccountLink.)

Para produzir vários cartões, você pode usar a propriedade iteratorVariable com o elemento card em um item de resposta do tipo cartões. Veja um exemplo de uso de cartão adaptável para produzir diversos cartões de pizza:

responseItems:
  - type: "cards"
    headerText: "Here are our pizzas you can order today:"
    cardLayout: "horizontal"
    cards:
      - title: "${pizzas.name}"
        description: "${pizzas.description}"
        imageUrl: "${pizzas.image}"
        iteratorVariable: "pizzas"
        actions:
          - label: "Order Now"
            type: "postback"
            payload:
              action: "order"
              variables:
                orderedPizza: "${pizzas.name}"
                orderedPizzaImage: "${pizzas.image}"
        channelCustomProperties:
        - channel: "msteams"
          properties:
            adaptiveCard:
              type: "AdaptiveCard"
              version: "1.0"
              fallbackText: "Adaptive card version not supported"
              body:
              - type: "TextBlock"
                text: "${pizzas.name}"
                weight: "bolder"
              - type: "TextBlock"
                text: "${pizzas.description}"
                wrap: true
              - type: "Image"
                url: "${pizzas.image}"
                horizontalAlignment: "center"
              actions:
              - type: "Action.Submit"
                title: "Order"
                data: 
                  action: "order" 
                  variables:
                    orderedPizza: "${pizzas.name}"
                    orderedPizzaImage: "${pizzas.image}"

Você pode definir um cartão adaptável com um item de resposta de texto da seguinte forma:

responseItems:
  - type: "text"
    text: "This text is replaced with adaptive card defined in custom property"
    footerText: "Is that correct?"
    visible:
      expression: "${system.channelType=='msteams' && system.entityToResolve.value.name=='Confirmed'}"
    channelCustomProperties:
      - channel: "msteams"
        properties:
          adaptiveCard:
            type: "AdaptiveCard"
            version: '1.0'          
            fallbackText: "Adaptive card version not supported"                                             
            body:
            - type: TextBlock
              text: 'I have all information needed to create your expense. Just to verify my understanding, here is an overview of your expense:'
              wrap: true
            - type: FactSet
              facts:
              - title: Expense Type
                value: "${expense.value.Type}"
              - title: Amount
                value: "${expense.value.Amount.totalCurrency}"
              - title: Date
                value: "${expense.value.Date.date?number_to_date}"
              - title: Receipt URL
                value: "${expense.value.Receipt?has_content?then(expense.value.Receipt.url,'N/A')}"
 
            actions:
            - type: Action.ShowCard
              title: Edit
              id: edit
              card:
                type: AdaptiveCard             
                version: '1.0'
                body:
                - type: TextBlock
                  size: Medium
                  weight: Bolder
                  text: Edit Expense
                - type: TextBlock
                  text: Expense Type
                  weight: Bolder
                - type: Input.ChoiceSet
                  choices:
                  - title: Metro, bus, train
                    value: Public transport
                  - title: Taxi
                    value: Taxi
                  - title: Breakfast, lunch, dinner
                    value: dinner
                  id: Type
                  value: "${expense.value.Type!''}"
                  spacing: None
                - type: TextBlock
                  text: Amount
                  weight: Bolder
                - type: Input.Text
                  id: amount
                  spacing: None
                  value: "${expense.value.Amount?has_content?then(expense.value.Amount.totalCurrency,'')}"
                - type: TextBlock
                  text: Date
                  weight: Bolder
                - type: Input.Date
                  id: Date
                  value: "${expense.value.Date?has_content?then(expense.value.Date.date?number_to_date,'')}"
                  spacing: None
                actions:
                - type: Action.Submit
                  title: Submit
                  id: submit

Também é possível definir vários cartões adaptáveis nessa propriedade personalizada. Para fazer isso, prefixe a propriedade type com uma traço (-) para indicar uma lista YAML em vez de um mapa:

channelCustomProperties:
  - channel: "msteams"
    properties:
      adaptiveCard:
      - type: AdaptiveCard
        body: ...
      - type: AdaptiveCard
        body: ...

Isso poderá ser conveniente se você precisar produzir vários cartões estáticos, mas será mais comum produzir diversos cartões usando a propriedade iteratorVariable.

Os Cartões Adaptáveis têm uma ação de envio (Action.Submit), que você pode usar para reunir a entrada do usuário e enviá-la à habilidade.

Defina o payload da ação na propriedade data da ação de envio. Se quiser que o componente Resposta Comum seja alterado após o botão ser selecionado ou definir algumas variáveis, você poderá usar as propriedades padrão action e variables:

actions:
- type: "Action.Submit"
  title: "Order"
  data: 
    action: "order" 
    variables:
      orderedPizza: "${pizzas.name}"
      orderedPizzaImage: "${pizzas.image}"

Caso esteja usando campos de entrada em seu cartão, o nome e o valor desses campos serão adicionados como pares de chave/valor ao objeto JSON data. O exemplo anterior com o cartão Editar Despesa inclui três campos para modificar o tipo, o valor e a data da despesa. Quando o usuário toca no botão Submeter nesse caso, um objeto JSON como este será enviado:

{
  "Type" : "Taxi",
  "Amount" : "10.0 dollar"
  "Date" : "2019-09-02"
}

O componente Resposta Comum não sabe como processar essas informações, porque ele não segue a estrutura de payload comum com as propriedades action e variables. Para resolver essa questão, você tem estas opções:

• Converta o payload JSON em uma string, que será correspondida para entidades. Se qualquer correspondência for encontrada, a variável definida com o componente será atualizado com os valores da entidade correspondente (no caso de uma entidade composta).

  Para configurar essa opção, adicione a propriedade booliana system.convertToString à propriedade data da ação de envio:

  actions:
  - type: Action.Submit
    title: Submit
    id: submit                   
    data:
      system.convertToString: true

• Faça com que a habilidade atualize variáveis com o mesmo nome dos campos de entrada. No exemplo anterior, as variáveis "Type", "Amount" e "Date" seriam atualizadas.

  Para configurar essa opção, adicione a propriedade booliana system.setVariables à propriedade data da ação de envio:

  actions:
  - type: Action.Submit
    title: Submit
    id: submit                   
    data:
      system.setVariables: true

Se você não configurar qualquer uma dessas opções, os valores submetidos serão simplesmente ignorados.

Ao usar um componente de Resposta Comum com uma entidade composta, você geralmente usará a primeira opção, que preencherá todas as entidades correspondentes no repositório com base no payload JSON identificado.

Quando um usuário seleciona um botão em um Cartão Adaptável, a conversa não é atualizada para mostrar que o usuário selecionou essa opção, a menos que você inclua uma ação messageBack para o cartão.

Para configurar uma ação messageBack, consulte https://docs.microsoft.com/en-us/microsoftteams/platform/task-modules-and-cards/cards/cards-actions#adaptive-cards-with-messageback-action.

Embora não seja possível desativar tecnicamente botões e campos em Cartões Adaptáveis, você pode criar um efeito semelhante substituindo o cartão quando uma ação de envio for chamada. Você faz isso usando a propriedade booliana replaceMessage específica dos componentes do Microsoft Teams in Common Response.

Para permitir que o cartão seja novamente renderizado dessa forma, adicione essa propriedade na seção channelCustomProperties do componente de resposta personalizado:

        ...
           - type: "text"
             text: "This text is replaced with the adaptive card defined in custom property"
             channelCustomProperties:
               - channel: "msteams"
                 properties:
                   replaceMessage: "true"
                   adaptiveCard:
                     ...

Você também pode usar uma expressão do Apache FreeMarker para definir o valor da propriedade.

O esquema JSON de cartões adaptáveis é relativamente complexo com diversas construções suportadas. Dessa forma, é propenso a erros quando você tenta definir o conteúdo do cartão adaptável à mão diretamente em um componente de Resposta Comum. Você pode achar mais fácil usar o seguinte processo para criar os cartões adaptáveis:

1. Com as ferramentas visuais no Microsoft Adaptive Cards Designer, crie a definição de cartão adaptável.
2. Clique em Copiar JSON do Cartão para obter a definição no formato JSON.
3. Use um conversor on-line (como https://jsonformatter.org/json-to-yaml) para converter a definição em YAML.
4. Copie o resultado em um editor de texto e insira o recuo necessário para o lugar onde ele aparecerá na definição do fluxo de caixas de diálogo.
5. Cole o texto resultante no fluxo de caixas de diálogo.