Criar receptores de eventos externos

Conheça as etapas para a criação de receptores de evento externo para instalações do local do Business Connectivity Services (BCS) listas externas.

Importante

Os Suplementos do SharePoint foram preteridos. Este conteúdo aplica-se apenas ao Servidor do SharePoint no local.

Receptores de evento externo são classes que permitem Suplementos do SharePoint responder aos eventos que ocorrem aos itens do SharePoint, como listas ou itens de lista. Por exemplo, você pode responder a eventos de lista, adicionar ou remover um campo; eventos de item de lista, como a adição ou remoção de um item de lista ou de um anexo a um item de lista; ou eventos de web, adicionando ou excluindo um site ou conjunto de sites. Pode adicionar um recetor de evento remoto a uma solução existente do Visual Studio que contenha um Suplemento do SharePoint.

Este artigo inclui o exemplo de código MSDN original para criar um recetor de eventos remotos para dados externos. Ele mostra como criar todos os componentes necessários para configurar e usar notificações de eventos do sistema externo.

Observação

O exemplo de código MSDN original referenciado neste artigo já não está disponível. Todos os passos e fragmentos de código necessários estão incluídos aqui.

Neste exemplo, irá fazer o seguinte:

  1. Criar um sistema externo com base no banco de dados Northwind
  2. Expor os dados de amostra por meio do OData, criando um serviço Windows Communication Foundation (WCF).
  3. Crie um serviço de consulta que monitorize as alterações nos dados e notifique o SharePoint dessas alterações.
  4. Crie um receptor de evento externo que executa quando itens são adicionados aos dados externos e, consequentemente, cria um novo item de lista em uma lista de notificações.

Pré-requisitos e configuração do sistema

Para concluir este exemplo, precisará dos seguintes pré-requisitos:

  • Visual Studio 2022
  • Ferramentas de Programador do Office para Visual Studio 2022
  • SQL Server
  • SharePoint
  • Serviços de Informações da Internet
  • Banco de dados de exemplo Northwind

Compilar os componentes para sistemas externos

A maior parte da configuração de realmente acontece no sistema externo. Para receptores de evento externo funcione corretamente, os seguintes componentes devem estar presente e funcionando no sistema externo:

  • Repositório de inscrição: Uma tabela que contém informações sobre os assinantes que deseja ser notificado das alterações aos dados externos.
  • Alterações armazenam: Uma tabela que é usada para armazenar as alterações nos itens de dados. Ele funciona como armazenamento temporário apenas porque o serviço de sondagem exclui o item na tabela quando as notificações são enviadas de volta para assinantes do SharePoint.
  • Serviço sondagem: Necessários neste cenário como um meio de verificação quando os dados foram alterados e enviados para a tabela de alteração. O serviço de sondagem de consulta a tabela de alteração e monta um pacote de notificação é enviado para o endereço de entrega do SharePoint (ponto de extremidade do REST) armazenado no repositório de inscrição.
  • Serviço de dados OData WCF: Para expor os dados do banco de dados do sistema externo, você precisa criar um serviço WCF. Em serviços de informações da Internet (IIS), a execução desse serviço fornece a interface por REST e OData feed que é necessária para este cenário.

Configurar o sistema externo

A primeira tarefa é configurar o sistema externo.

Anexe o banco de dados de exemplo Northwind

A primeira parte do Preparando o sistema back-end é adicionar o banco de dados de exemplo Northwind para uma instância do SQL Server em execução. Se você já tiver o banco de dados de exemplo Northwind instalado, você pode executar os scripts na seção a seguir para criar objetos adicionais necessários para notificações de eventos externos trabalhar.

No entanto, se não tiver a Northwind instalada, veja Instalar a Base de Dados de Exemplo da Northwind.

Criar o repositório de inscrição

Quando o banco de dados Northwind está instalado, abra uma nova janela de consulta e execute o script a seguir.

USE [Northwind]
GO

SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE TABLE [dbo].[EntitySubscribe](
    [SubscriptionId] [int] IDENTITY(1,1) NOT NULL,
    [EntityName] [nvarchar](250) NULL,
    [DeliveryURL] [nvarchar](250) NULL,
    [EventType] [int] NULL,
    [UserId] [nvarchar](50) NULL,
    [SubscribeTime] [timestamp] NULL,
    [SelectColumns] [nvarchar](10) NULL,
 CONSTRAINT [PK_Subscribe] PRIMARY KEY CLUSTERED ([SubscriptionId] ASC) WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO

Isso cria uma tabela no banco de dados Northwind chamado EntitySubscribe. Isso serve como o repositório de inscrição, anteriormente.

Criar o repositório de alteração

Execute o seguinte script para criar a tabela de alteração que irá registrar as alterações nos dados da tabela Customers.

USE [Northwind]
GO

SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE TABLE [dbo].[Customers_Updates](
    [CustomerID] [nchar](5) NOT NULL,
    [CompanyName] [nvarchar](40) NOT NULL,
    [ContactName] [nvarchar](30) NULL,
    [ContactTitle] [nvarchar](30) NULL,
    [Address] [nvarchar](60) NULL,
    [City] [nvarchar](15) NULL,
    [Region] [nvarchar](15) NULL,
    [PostalCode] [nvarchar](10) NULL,
    [Country] [nvarchar](15) NULL,
    [Phone] [nvarchar](24) NULL,
    [Fax] [nvarchar](24) NULL,
    [TimeAdded] [datetime] NULL,
    [EventType] [int] NULL,
 CONSTRAINT [PK_Customers_Updates] PRIMARY KEY CLUSTERED ([CustomerID] ASC)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]) ON [PRIMARY]
GO

Isso adiciona uma tabela chamada Customers_Updates que armazena as informações sobre o registro que foi adicionado à tabela Customers.

Criar o gatilho de alteração

O gatilho alteração é disparado quando as alterações ocorrem à tabela Customers. Sempre que um registro é adicionado aos clientes, o SQL Server executa o gatilho, que insere um novo registro na tabela Customers_Updates com as informações sobre o registro.

Para criar o gatilho, execute a seguinte consulta.

USE [Northwind]
GO

SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE trigger [dbo].[Customer_insupd] on [dbo].[Customers] for
INSERT
AS
DECLARE
    @CustomerID nchar(5),
    @CompanyName nvarchar(40),
    @ContactName nvarchar(30) ,
    @ContactTitle nvarchar(30) ,
    @Address nvarchar(60) ,
    @City nvarchar(15) ,
    @Region nvarchar(15) ,
    @PostalCode nvarchar(10) ,
    @Country nvarchar(15) ,
    @Phone nvarchar(24) ,
    @Fax nvarchar(24),
    @TimeAdded datetime,
    @EventType int

    Select @CustomerID = CustomerId, @CompanyName=CompanyName,
    @ContactName=ContactName, @ContactTitle=ContactTitle,
    @Address=Address, @City=City, @Region=Region,
    @PostalCode =PostalCode, @Country=Country,
    @Phone=Phone,@Fax=Fax,@EventType=1
    from inserted

    insert into Customers_Updates
    (CustomerId,CompanyName,
    ContactName, ContactTitle,
    Address, City, Region,
    PostalCode,Country,
    Phone,Fax,TimeAdded,EventType) values
    (@CustomerId,@CompanyName,
    @ContactName, @ContactTitle,
    @Address, @City, @Region,
    @PostalCode,@Country,
    @Phone,@Fax,SYSDATETIME(),@EventType)

GO

Observação

Se estiver a utilizar os seus próprios procedimentos armazenados personalizados, conforme definido no modelo BDC, também poderá querer criar os acionadores de eliminação e atualização. Os acionadores adicionais não são abrangidos como parte deste cenário.

Criar os procedimentos armazenados

Se estiver a utilizar o acesso direto à tabela com os Serviços de Conectividade Empresarial, estes procedimentos não serão necessários. No entanto, se estiver a definir os seus próprios procedimentos e código personalizado no sistema externo, poderá querer adicioná-los para permitir o acesso à tabela a partir de SQL Server.

// DeleteEventRecords stored procedure
USE [Northwind]
GO
SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE PROCEDURE [dbo].[proc_DeleteEventRecords]
    @CustomerID nchar(5), @EventType int
    AS
    Delete from Customers_Updates
    WHERE  CustomerID like @CustomerID AND EventType=@EventType

GO

O procedimento SubscribeEntity armazenados criará um registro no repositório de inscrição.

// SubscribeEntity
USE [Northwind]
GO

SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

CREATE PROCEDURE [dbo].[SubscribeEntity]
    @EntityName Varchar(255),
    @EventType Integer,
    @DeliveryAddress Varchar(255),
    @SelectColumns Varchar(10)

AS
BEGIN
    -- SET NOCOUNT ON added to prevent extra result sets from
    -- interfering with SELECT statements.
    SET NOCOUNT ON;

    -- Insert statements for procedure here

    Insert into EntitySubscribe(EntityName,DeliveryURL,EventType,SelectColumns)
    values (@EntityName,@DeliveryAddress,@EventType,@SelectColumns)

END

GO

Criar o serviço OData

O feed do OData é hospedado dentro de um Serviço de dados do WCF. Esse serviço WCF é hospedado pelo IIS em um aplicativo web.

As etapas a seguir criam um novo serviço de dados do ASP.NET WCF.

Para criar o aplicativo de serviço de dados de WCF

  1. No Visual Studio 2022, no menu Ficheiro , selecione Novo, Projeto.
  2. Na caixa de diálogo Novo projeto, no nó do Visual c#, escolha o modelo da Web e, em seguida, escolha o Aplicativo Web ASP.NET.
  3. Digite NorthwindService como o nome do projeto e escolha OK.

Em seguida, usando o Assistente do Visual Studio, você descobrir o esquema da fonte de dados e usá-lo para criar um modelo de dados do ADO.NET entity.

Para definir o modelo de dados

  1. No Gerenciador de Soluções, abra o menu de atalho para o projeto do ASP.NET e escolha Adicionar Novo Item.

  2. Na caixa de diálogo Adicionar Novo Item, escolha o modelo de dados e, em seguida, escolha o Modelo de dados do ADO.NET Entity.

  3. O nome do modelo de dados, digite Northwind.edmx.

  4. No Assistente de modelo de dados de entidade, escolha a geração do banco de dados e escolha Avançar.

  5. Conecte o modelo de dados no banco de dados, executando um dos seguintes passos:

  6. Se ainda não tiver uma ligação de base de dados configurada, selecione Nova Ligação e crie uma nova ligação. Para obter mais informações, consulte como: criar conexões com bancos de dados do SQL Server. Esta instância do SQL Server deve ter um banco de dados de exemplo e anexado. Escolha Avançar.

    -ou-

  7. Se você tiver uma conexão de banco de dados já configurada para se conectar ao banco de dados Northwind, escolha essa conexão na lista de conexões e escolha Avançar.

  8. Na página final do assistente, marque as caixas de seleção para todas as tabelas no banco de dados e desmarque as caixas de seleção dos modos de exibição e procedimentos armazenados.

  9. Escolha o botão Concluir para fechar o assistente.

A próxima etapa, você cria o serviço real que é hospedado pelo IIS que fornecerá os meios para acessar dados externos através de Representational State Transfer (REST).

Para criar o serviço de dados do WCF

  1. No Gerenciador de Soluções, abra o menu de atalho para o seu projeto do ASP.NET e escolha Adicionar Novo Item.
  2. Na caixa de diálogo Adicionar Novo Item, escolha WCF Data Service.
  3. O nome do serviço, digite Northwind.
  4. No código do serviço de dados, na definição da classe que define o serviço de dados, substitua o comentário /* TODO: put your data source class name here */ pelo tipo que é o contentor de entidades do modelo de dados, que neste caso é NorthwindEntities. A definição da classe deve se parecer com o seguinte.
public class Northwind : DataService<NorthwindEntities>

Definir a segurança no serviço

  • Agora você tem que modificar a segurança para permitir o acesso aos dados do feed por consumidores externos do OData. Quando um serviço WCF é criado, todo o acesso negado por padrão. Efetue as seguintes alterações à classe que criou.

config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);

Criar a operação de serviço de assinatura (opcional)

O serviço WCF também pode ser codificado com um meio de lidar com as solicitações de inscrição e o cancelamento da assinatura do SharePoint. Se optar por criar procedimentos armazenados personalizados para a sua aplicação, cada um deles será processado por uma operação de serviço.

Inscrever-se: inscrever-se a operação assume a solicitação enviada pelo SharePoint e recupera o endereço do destinatário, o tipo de evento e a entidade. Ele também tem que gerar um subscriptionId e depois gravar todos esses para a tabela de banco de dados.


/// The Subscribe service operation maps directly to the Subscribe stereotype
/// found in the BDC model

[WebGet]
public string Subscribe(string deliveryUrl, string eventType)
{
   // Generate a new Guid that will function as the subscriptionId.
  string subscriptionId = new Guid().ToString();

  // This sproc will be used to create the subscription in the database.
  string subscribeSproc = "SubscribeEntity";

  // Create connection to database.
  using (SqlConnection conn = new SqlConnection(sqlConn))
  {
    SqlCommand cmd = new SqlCommand(subscribeSproc, conn);
    cmd.Parameters.Add(new SqlParameter("SubscriptionId", subscriptionId));
    cmd.Parameters.Add(new SqlParameter("EntityName", entityName));
    cmd.Parameters.Add(new SqlParameter("EventType", eventType));
    cmd.Parameters.Add(new SqlParameter("DeliveryAddress", deliveryUrl));
    cmd.Parameters.Add(new SqlParameter("SelectColumns", selectColumns));

    try
    {
      conn.Open();
      cmd.ExecuteNonQuery();
  }
    catch (Exception e)
    {
      throw e;
    }
    finally
    {
      conn.Close();
    }

    return subscriptionId;
  }
}

Observação

[!OBSERVAçãO] Se o SQL Server está configurado para autenticação do Windows, ele tentará autenticar a solicitação com a identidade do Pool de aplicativos. Certifique-se de que a conta configurada no Pool de aplicativos tem direitos para ler e gravar no banco de dados.

Criar o serviço de sondagem

O serviço de consulta é um serviço windows responsável por consultar a tabela de alterações e criar e enviar notificações para o SharePoint ou SharePoint Online no endereço de entrega específico.

Em seguida, você deve criar um novo projeto de serviço do Windows que será registrado na máquina host WCF. Quando o projeto estiver registrado, você pode exibir a execução do serviço no Console de gerenciamento Microsoft (MMC).

Para criar um novo projeto

  1. Abra o Visual Studio 2022.
  2. Criar um novo projeto usando o modelo de serviço do Windows, o nome do projeto PollingServicee escolha o botão OK.
  3. Quando o projeto é criado, abra o arquivo de PollingService.cs no modo de exibição de código.
  4. Adicione o seguinte código na classe recém-criado.
public partial class PollingService : ServiceBase
{
  string subscriptionStorePath = string.Empty;

  public PollingService()
  {
    InitializeComponent();
  }

  protected override void OnStart(string[] args)
  {
    // This is the timer which fires every minute.
    System.Timers.Timer aTimer = new System.Timers.Timer();
    aTimer.Elapsed += new System.Timers.ElapsedEventHandler(SendEventNotification);
    aTimer.Interval = 60000;
    aTimer.Enabled = true;
  }

  protected override void OnStop()
  { }

  private void SendEventNotification(object sender, EventArgs e)
  {
    try
    {
      List<ItemChange> events = itemChangeLookUp();
      triggerEventPerSubscription(events);
    }
    catch (Exception ex)
    {
      EventLog.Log = "Application";
      EventLog.Source = ServiceName;
      EventLog.WriteEntry("PollingService" + ex.Message, EventLogEntryType.Error);
    }
  }

  private void triggerEventPerSubscription(List<ItemChange> events)
  {
    foreach (ItemChange itemChangeEvent in events)
    {
      SendNotification(itemChangeEvent, itemChangeEvent.DeliveryAddress);
      string message = string.Format("PollingService.TriggerEventPerSubscription: Notification sent for item {0} of eventType {1}", itemChangeEvent.CustomerId, itemChangeEvent.EventType);
      EventLog.Log = "Application";
      EventLog.Source = ServiceName;
      EventLog.WriteEntry(message);
    }
  }

  private List<ItemChange> itemChangeLookUp()
  {
    EventLog.Log = "Application";
    EventLog.Source = ServiceName;
    EventLog.WriteEntry("Polling for Item Change");
    List<ItemChange> itemChangeList = new List<ItemChange>();
    string connectionString = "Data Source=.;Initial Catalog=Northwind;Integrated Security=true";

    // Provide the query string with a parameter placeholder.
    string queryString = "Proc_RetrieveEventRecords";

    // Specify the parameter value.
    int paramValue = -50;

    using (SqlConnection connection = new SqlConnection(connectionString))
    {
      SqlCommand command = new SqlCommand(queryString, connection);
      command.CommandType = CommandType.StoredProcedure;
      command.Parameters.AddWithValue("@TimeSince", paramValue);
      try
      {
        connection.Open();
        SqlDataReader reader = command.ExecuteReader();
        while (reader.Read())
        {
          ItemChange item = new ItemChange(reader["CustomerID"].ToString(), Int32.Parse(reader["EventType"].ToString()),
            reader[14].ToString(), reader["DeliveryUrl"].ToString(), reader["CompanyName"].ToString(),
            reader["ContactName"].ToString(), reader["ContactTitle"].ToString(), reader["Address"].ToString(),
            reader["City"].ToString(), reader["Region"].ToString(), reader["Country"].ToString(), reader["PostalCode"].ToString(),
            reader["Phone"].ToString(), reader["Fax"].ToString());
          itemChangeList.Add(item);
        }
        reader.Close();
      }
      catch (Exception ex)
      {
        EventLog.Log = "Application";
        EventLog.Source = ServiceName;
        EventLog.WriteEntry("PollingService : ItemChangeLookup " + ex.Message, EventLogEntryType.Error);
      }
    }
    string message = string.Format("{0} items changes", itemChangeList.Count);
    EventLog.Log = "Application";
    EventLog.Source = ServiceName;
    EventLog.WriteEntry(message);

    return itemChangeList;
  }

A próxima etapa é criar um arquivo executável que pode ser adicionado para os serviços em execução no computador OData.

Para compilar e implantar o serviço de sondagem

  1. Pressione F5 para criar seu projeto.
  2. Abra a Linha de Comandos do VS2022.
  3. No prompt, navegue até o seu local de saída do projeto.
  4. No diretório Bin, localize o arquivo de PollingService.exe.
  5. Introduza installutil PollingService.exe e prima Enter.
  6. Verifique se o serviço está em funcionamento, executando serviços do MMC.

Componentes necessários do SharePoint

Para concluir todo o sistema, são necessários os seguintes componentes no servidor que está a executar o SharePoint.

  • Tipo de conteúdo externo: O tipo de conteúdo externo é basicamente uma definição de XML da fonte de dados externa. Neste cenário, irá utilizar as novas ferramentas de autogeração no Visual Studio 2022 para detetar a origem de dados e criar automaticamente o tipo de conteúdo externo.

  • Recetor de eventos externos: O recetor de eventos remoto ou externo é o que possibilita ações em alterações de dados externos no SharePoint. Você pode criar receptores de evento para listas externas e entidades.

    Um receptor de evento que é criado para uma lista externa é semelhante a outros receptores de evento de listas do SharePoint. Você cria o código e anexá-lo à lista. Quando uma ação é executada nos dados que são representados por lista, o receptor de evento executa.

    Um receptor de evento para entidades é executado como um receptor de evento baseados em lista, exceto que ele não precisa ser anexado a uma lista. Ele recebe notificações da mesma maneira, mas ele não precisa a interface que está associada com o exemplo baseados em lista. A vantagem disso é que podem ser intercept as notificações de maneira programática e criar o código para executar alguma ação. Neste cenário, essa ação é criar um novo registro na lista de notificações

  • Lista de notificações: A lista de notificações é uma lista do SharePoint simple que é usada para registrar as notificações recebidas do sistema externo. Para cada novo registro adicionado para o sistema externo, um registro é criado na lista de notificações.

Configurar os componentes do SharePoint

Agora que você tem o sistema externo, configurar, é hora para mover-se para criar a outra metade da equação. Agora, irá criar os componentes a alojar no SharePoint.

Para criar um novo projeto do Visual Studio 2022

  1. No Visual Studio 2022, selecione Novo Projeto.
  2. Escolha o modelo de projeto de aplicativo do SharePoint.

As Ferramentas de Programador do Office para Visual Studio 2022 adicionaram um assistente de geração automática que irá detetar o esquema de uma origem de dados e, em seguida, criar um tipo de conteúdo externo a partir daí.

Para adicionar um novo tipo de conteúdo externo

  • No Gerenciador de Soluções, abra o menu de atalho para o projeto e escolha Adicionar, Tipos de conteúdo para uma fonte de dados externa.

    Isso inicia o Assistente de personalização do SharePoint, que é usado para construir automaticamente o tipo de conteúdo externo.

    Para obter mais informações sobre como criar tipos de conteúdo externo, consulte Como: Criar um tipo de conteúdo externo a partir de uma origem OData no SharePoint.

Agora, irá modificar o XML que foi gerado no passo anterior para adicionar um método para Subscrever. Isso permitirá que o BCS para se comunicar com o sistema externo, quando alguém se inscreve para ser notificado sobre alterações de dados externos.

Para adicionar o método Subscribe para o tipo de conteúdo externo XML

  1. No Gerenciador de Soluções, localize o novo nó denominado Tipos de conteúdo externo.
  2. Localize o arquivo Customers.ect e abra-o com um editor de XML.
  3. Desloque-se para baixo até à parte inferior da página e cole o seguinte método na <Methods> secção .

<Method Name="SubscribeCustomer" DefaultDisplayName="Customer Subscribe" IsStatic="true">
              <Properties>
                <Property Name="ODataEntityUrl" Type="System.String">/EntitySubscribes</Property>
                <Property Name="ODataHttpMethod" Type="System.String">POST</Property>
                <Property Name="ODataPayloadKind" Type="System.String">Entry</Property>
                <Property Name="ODataFormat" Type="System.String">application/atom+xml</Property>
                <Property Name="ODataServiceOperation" Type="System.Boolean">false</Property>
              </Properties>
              <AccessControlList>
                <AccessControlEntry Principal="NT Authority\\Authenticated Users">
                  <Right BdcRight="Edit" />
                  <Right BdcRight="Execute" />
                  <Right BdcRight="SetPermissions" />
                  <Right BdcRight="SelectableInClients" />
                </AccessControlEntry>
              </AccessControlList>
              <Parameters>
                <Parameter Direction="In" Name="@DeliveryURL">
                  <TypeDescriptor TypeName="System.String" Name="DeliveryURL" >
                    <Properties>
                      <Property Name="IsDeliveryAddress" Type="System.Boolean">true</Property>
                    </Properties>
                  </TypeDescriptor>
                </Parameter>
                <Parameter Direction="In" Name="@EventType">
                  <TypeDescriptor TypeName="System.Int32" Name="EventType" >
                    <Properties>
                      <Property Name="IsEventType" Type="System.Boolean">true</Property>
                    </Properties>
                  </TypeDescriptor>
                </Parameter>
                <Parameter Direction="In" Name="@EntityName">
                  <TypeDescriptor TypeName="System.String" Name="EntityName" >
                    <DefaultValues>
                      <DefaultValue MethodInstanceName="SubscribeCustomer" Type="System.String">Customers</DefaultValue>
                    </DefaultValues>
                  </TypeDescriptor>
                </Parameter>
                <Parameter Direction="In" Name="@SelectColumns">
                  <TypeDescriptor TypeName="System.String" Name="SelectColumns" >
                    <DefaultValues>
                      <DefaultValue MethodInstanceName="SubscribeCustomer" Type="System.String">*</DefaultValue>
                    </DefaultValues>
                  </TypeDescriptor>
                </Parameter>
                <Parameter Direction="Return" Name="SubscribeReturn">
                  <TypeDescriptor Name="SubscribeReturnRootTd" TypeName="Microsoft.BusinessData.Runtime.DynamicType">
                    <TypeDescriptors>
                      <TypeDescriptor Name="SubscriptionId" TypeName="System.String" >
                        <Properties>
                          <Property Name="SubscriptionIdName" Type="System.String">Default</Property>
                        </Properties>
                        <Interpretation>
                          <ConvertType LOBType="System.Int32" BDCType="System.String"/>
                        </Interpretation>
                      </TypeDescriptor>
                      <TypeDescriptor Name="DeliveryURL" TypeName="System.String" />
                      <TypeDescriptor Name="SelectColumns" TypeName="System.String" >
                      </TypeDescriptor>
                      <TypeDescriptor Name="EntityName" TypeName="System.String" />
                      <TypeDescriptor Name="EventType" TypeName="System.Int32" />
                      <TypeDescriptor Name="UserId" TypeName="System.String" />
                      <!--TypeDescriptor Name="SubscribeTime" TypeName="System." /-->
                    </TypeDescriptors>
                  </TypeDescriptor>
                </Parameter>
              </Parameters>
              <MethodInstances>
                <MethodInstance Type="EventSubscriber" ReturnParameterName="SubscribeReturn" ReturnTypeDescriptorPath="SubscribeReturnRootTd" Default="true" Name="SubscribeCustomer" DefaultDisplayName="Customer Subscribe">
                  <AccessControlList>
                    <AccessControlEntry Principal="NT Authority\\Authenticated Users">
                      <Right BdcRight="Edit" />
                      <Right BdcRight="Execute" />
                      <Right BdcRight="SetPermissions" />
                      <Right BdcRight="SelectableInClients" />
                    </AccessControlEntry>
                  </AccessControlList>
                </MethodInstance>
              </MethodInstances>
            </Method>

Agora, irá adicionar código de cliente para permitir que a sua lista subscreva as notificações de eventos.

Para adicionar código ao arquivo App.js para iniciar a assinatura

  • Na pasta Scripts do seu projeto Suplemento do SharePoint, abra o arquivo de App.js. Cole o seguinte método para o arquivo.

function SubscribeEntity()
{
    var notificationCallback = new SP.BusinessData.Runtime.NotificationCallback(context, "http://[MACHINE NAME]:8585");
    var url = myweb.get_url();
    notificationCallback.set_notificationContext(url);
    context.load(notificationCallback);
    var subscription = entity.subscribe(1, notificationCallback, "", "SubscribeCustomer", lobSystemInstance);
    context.load(subscription);
    context.executeQueryAsync(OnSubscribeSuccess, failmethod);
}

Para registrar o receptor de evento com esse script, você precisa criar um botão na página Default. aspx em seu projeto e o SubscribeEntity() de chamada do método onclick().

  • Abra a página Default. aspx e adicione a seguinte HTML.

<input type="button" value="Subscribe" onclick="SubscribeEntity();"/>

Para eventos funcione, você também deve ativar a lista do SharePoint aceitar a eventos externos. Isso é feito ativem o recurso de eventos externos.

A seguir está um script que irá ativar o recurso usando o código do cliente.

function EnableEventing_Clicked()
{
    var clientContext = SP.ClientContext.get_current();
    var web = clientContext.get_web();
    var features = web.get_features();

    clientContext.load(features);

    // The GUID provided here is the feature that allows external events and alerts.
    var eventingFeatureId = new SP.Guid('5B10D113-2D0D-43BD-A2FD-F8BC879F5ABD');

    var eventingFeature = features.add(eventingFeatureId, true, SP.FeatureDefinitionScope.farm);

    clientContext.load(eventingFeature);
    var onEventingFeatureActivated = function () {
        alert("eventing feature activated");
    };
    clientContext.executeQueryAsync(Function.createDelegate(this,
    onEventingFeatureActivated));
}

Tal como com Subscrever, irá adicionar um botão à página que irá ativar a funcionalidade.

Adicione o seguinte HTML para a página Default. aspx, logo abaixo do botão inscrever.


<input type="button" value="EnableEventing" onclick="EnableEventing_Clicked();" />

Em seguida, para este cenário, você deve adicionar uma lista de notificações mostrará as notificações enviadas pelo sistema externo.

Para adicionar a lista de notificações

  1. No Gerenciador de Soluções, abra o menu de atalho para o nome do projeto e escolha Adicionar.
  2. Escolha o modelo de lista e nomeie a listaNotificationList.

Para imitar um receptor de evento que é registrado com o SharePoint no cache de assembly global, o exemplo fornece um aplicativo de console que iniciará a escuta para que as alterações. Quando ele recebe uma notificação, ele adiciona um item de lista para o NotificationList.

Para iniciar o receptor de evento de linha de comando

  1. Abra o RemoteEventReceiverConsoleApp.

  2. Abra o arquivo Module. vb e altere o nome do computador local (ou o computador onde o receptor de evento será executado).

  3. Selecione o botão Iniciar no Visual Studio para executar a aplicação de consola.

    É aberta uma janela de comando, que indica que a aplicação foi compilada corretamente e está a escutar notificações de alteração do sistema externo. Deixe essa janela aberta durante este teste.

Para implantar o aplicativo para SharePoint

  • Abra o pressione F5 com o Visual Studio para criar e implantar o aplicativo.

O aplicativo de teste

Agora você pode ver o aplicativo em ação.

  1. Circular o aplicativo para ver as listas diferentes que representam os dados no sistema externo.

  2. Selecione a lista Clientes .

  3. Adicione um novo cliente.

  4. Veja o novo item de lista que criou.

  5. Vá para a lista de notificações para ver se o sistema externo notificou SharePoint de uma alteração à tabela Customers.

    Tenha em mente que o cronômetro é configurado para enviar notificações de cada um minuto. Durante o teste, você pode precisar aguardar por um breve período antes de ver as notificações lançadas.

Confira também

  • Last updated on