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.
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. Você pode adicionar um receptor de evento remoto para uma solução Visual Studio existente que contém um Suplemento do SharePoint.
Este artigo acompanha o exemplo de código SharePoint: criar um receptor de eventos remoto para dados externos. Ele mostra como criar todos os componentes necessários para configurar e usar notificações de eventos do sistema externo. Neste exemplo, você irá fazer o seguinte:
Criar um sistema externo com base no banco de dados Northwind
Expor os dados de amostra por meio do OData, criando um serviço Windows Communication Foundation (WCF).
Crie um serviço de sondagem que monitorará as alterações nos dados e notificará o SharePoint dessas alterações.
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, você precisará dos seguintes pré-requisitos:
Visual Studio 2012
Office Developer Tools para Visual Studio 2013
SQL Server
SharePoint
Internet Information Services 7.0
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 você não tiver o Northwind instalado, consulte Instalando o Banco de Dados de Exemplo northwind.
O banco de dados também está incluído com o exemplo de código: SharePoint: Criar um receptor de eventos remoto para dados externos.
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
f você está usando seus próprios procedimentos armazenados personalizados conforme definido em seu modelo BDC, você também pode querer criar os gatilhos de exclusão e atualização. Os disparadores adicionais não estão cobertos como parte desse cenário.
Criar os procedimentos armazenados
Se você estiver usando o acesso direto à tabela com os serviços corporativos de conectividade, estes procedimentos não será necessários. No entanto, se você estiver definindo sua própria procedimentos e código personalizado no sistema externo, você talvez queira adicioná-los para permitir o acesso à tabela do 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
No Visual Studio 2012, no menu arquivo, escolha novoprojeto.
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.
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
No Solution Explorer, abra o menu de atalho para o projeto do ASP.NET e escolha Adicionar Novo Item.
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.
O nome do modelo de dados, digite Northwind.edmx.
No Assistente de modelo de dados de entidade, escolha a geração do banco de dados e escolha Avançar.
Conecte o modelo de dados no banco de dados, executando um dos seguintes passos:
Se você não tiver uma conexão de banco de dados já configurada, escolha Nova conexão e criar uma nova conexã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-
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.
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.
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
No Solution Explorer, abra o menu de atalho para o seu projeto do ASP.NET e escolha Adicionar Novo Item.
Na caixa de diálogo Adicionar Novo Item, escolha WCF Data Service.
O nome do serviço, digite Northwind.
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 contêiner de entidade do modelo de dados, que nesse 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. Faça as seguintes alterações para a classe que você acabou de criar.
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 você optar por criar procedimentos armazenados personalizados para o seu aplicativo estes serão cada administrada 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 sondagem é 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
Abra o Visual Studio 2012.
Criar um novo projeto usando o modelo de serviço do Windows, o nome do projeto PollingServicee escolha o botão OK.
Quando o projeto é criado, abra o arquivo de PollingService.cs no modo de exibição de código.
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
Pressione F5 para criar seu projeto.
Abra o Prompt de comando para VS2012.
No prompt, navegue até o seu local de saída do projeto.
No diretório Bin, localize o arquivo de PollingService.exe.
Insira installutil PollingService.exe e pressione Enter.
Verifique se o serviço está em funcionamento, executando serviços do MMC.
Componentes necessários do SharePoint
Para concluir todo o sistema, os seguintes componentes são necessários no servidor que está executando o SharePoint.
Tipo de conteúdo externo: O tipo de conteúdo externo é basicamente uma definição de XML da fonte de dados externa. Para este cenário, você usará as novas ferramentas de geração automática no Visual Studio 2012 para descobrir a fonte de dados e criar automaticamente o tipo de conteúdo externo.
Receptor de eventos externo: O receptor de eventos remoto ou externo é o que torna possíveis ações sobre 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, você criará os componentes sejam hospedados no SharePoint.
Para criar um novo projeto do Visual Studio 2012
No Visual Studio 2012, escolha Novo projeto.
Escolha o modelo de projeto de aplicativo do SharePoint.
Office Developer Tools para Visual Studio 2013 adicionado um será descobrir o esquema da fonte de dados e, em seguida, criar um tipo de conteúdo externo do Assistente de geração automática.
Para adicionar um novo tipo de conteúdo externo
No Solution Explorer, 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 externos, consulte Como criar um tipo de conteúdo externo a partir de uma fonte OData no SharePoint.
Agora você modificará o XML que foi gerado na etapa anterior para adicionar um método para inscrever-se. 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
No Solution Explorer, localize o novo nó denominado Tipos de conteúdo externo.
Localize o arquivo Customers.ect e abra-o com um editor de XML.
Role para baixo até a parte inferior da página e cole o seguinte método na
<Methods>seçã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, você irá adicionar o código do cliente para permitir que a sua lista assinar notificações de evento.
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));
}
Assim como com Subscribe, você adicionará um botão para a página que irá ativar o recurso.
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
No Solution Explorer, abra o menu de atalho para o nome do projeto e escolha Adicionar.
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
Abra o RemoteEventReceiverConsoleApp.
Abra o arquivo Module. vb e altere o nome do computador local (ou o computador onde o receptor de evento será executado).
Clique no botão Iniciar no Visual Studio para executar o aplicativo de console.
Abre uma janela de comando, que indica que o aplicativo compilado corretamente, e ele está escutando para 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.
Circular o aplicativo para ver as listas diferentes que representam os dados no sistema externo.
Clique na lista de clientes.
Adicione um novo cliente.
Exiba o novo item de lista que você acabou de criar.
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.