Crear receptores de eventos externos
Aprenda los pasos para la creación de receptores de eventos externos para instalaciones locales de Servicios de conectividad empresarial (BCS) listas externas.
Receptores de eventos externos son clases que permiten Complementos de SharePoint responder a eventos que ocurren en elementos de SharePoint, como listas o elementos de lista. Por ejemplo, se puede responder a eventos de lista, como agregar o quitar un campo; eventos de elemento de lista, como agregar o quitar un elemento de lista o datos adjuntos a un elemento de lista; o eventos de web, como agregar o eliminar un sitio o una colección de sitios. Puede agregar un receptor de eventos remotos a una solución existente de Visual Studio que contiene un Complemento de SharePoint.
Este artículo acompaña al ejemplo de código SharePoint: Crear un receptor de eventos remoto para datos externos. Muestra cómo crear todos los componentes necesarios para configurar y usar las notificaciones de eventos de sistema externo. En este ejemplo, hará lo siguiente:
Crear un sistema externo basado en la base de datos de ejemplo Northwind
Exponer los datos de ejemplo a través de OData mediante la creación de un servicio de Windows Communication Foundation (WCF).
Cree un servicio de sondeo que supervise los cambios en los datos y notifique a SharePoint esos cambios.
Crear un receptor de eventos externos que se ejecuta cuando se agregan elementos a los datos externos y, como resultado, se crea un nuevo elemento de lista en una lista de notificaciones.
Requisitos previos y la configuración del sistema
Para completar este ejemplo, necesitará los siguientes requisitos previos:
Visual Studio 2012
Office Developer Tools para Visual Studio 2013
SQL Server
SharePoint
Internet Information Services 7.0
Base de datos de ejemplo Northwind
Crear los componentes de los sistemas externos
La mayor parte de la configuración en realidad sucede en el sistema externo. Para que receptores de eventos externos para que funcione correctamente, los siguientes componentes deben ser presentes y en funcionamiento en el sistema externo:
Almacén de suscripción: Una tabla que contiene información acerca de los suscriptores que desea recibir una notificación de cambios a los datos externos.
Almacenan cambios: Una tabla que se usa para almacenar los cambios realizados en los elementos de datos. Funciona como almacén temporal sólo porque el servicio de sondeo elimina el elemento en la tabla cuando se envían a los suscriptores en SharePoint.
Servicio de sondeo: Se requiere en este escenario como medio de comprobación cuando datos ha cambiado y se envía a la tabla de cambio. El servicio de sondeo de consulta en la tabla de cambio y ensambla un paquete de notificación que se envía a la dirección de entrega de SharePoint (extremo de REST) almacenada en el almacén de suscripción.
Servicio de datos de WCF OData: Para exponer los datos de base de datos del sistema externo, debe crear un servicio WCF. Este servicio, que se ejecuta en Internet Information Services (IIS), proporciona la interfaz REST y OData de fuente que se necesita para este escenario.
Configurar el sistema externo
La primera tarea es configurar el sistema externo.
Adjuntar la base de datos de ejemplo Northwind
Es la primera parte de la preparación del sistema back-end agregar la base de datos de ejemplo Northwind a una instancia en ejecución de SQL Server. Si ya tiene la base de datos de ejemplo Northwind instalado, puede ejecutar las secuencias de comandos en la sección siguiente para crear los objetos adicionales necesarios para que las notificaciones de eventos externos para que funcione.
Sin embargo, si no tiene Northwind instalado, consulte Instalación de la base de datos de ejemplo Northwind.
La base de datos también se incluye con el ejemplo de código: SharePoint: Crear un receptor de eventos remoto para datos externos.
Crear el almacén de suscripción
Cuando se instala la base de datos Northwind, abra una nueva ventana de consulta y ejecute la siguiente secuencia de comandos.
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
Esto crea una tabla en la base de datos de Northwind denominado EntitySubscribe. Esto sirve como el almacén de suscripción mencionados anteriormente.
Crear el almacén de cambio
Ejecute el siguiente script para crear la tabla de cambio que se va a guardar los cambios realizados en los datos en la tabla 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
Esto agrega una tabla denominada Customers_Updates que almacena la información sobre el registro que se ha agregado a la tabla Customers.
Crear el desencadenador de cambio
El desencadenador de cambio se activa cuando se producen cambios a la tabla Customers. Cada vez que se agrega un registro a los clientes, SQL Server ejecuta el desencadenador, que inserta un nuevo registro en la tabla Customers_Updates con la información sobre el registro.
Para crear el desencadenador, ejecute la consulta siguiente.
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
Nota:
Si usa sus propios procedimientos almacenados personalizados tal como se define en el modelo de BDC, es posible que también quiera crear los desencadenadores de eliminación y actualización. No se se tratan los desencadenadores adicionales como parte de este escenario.
Crear los procedimientos almacenados
Si usa el acceso directo a tablas con servicios de conectividad empresarial, estos procedimientos no será necesarios. Sin embargo, si va a definir sus propios procedimientos y código personalizado en el sistema externo, es posible que desee agregar estos para permitir el acceso a la tabla 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
El procedimiento SubscribeEntity almacenado creará un registro en el almacén de suscripción.
// 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
Crear el servicio OData
La fuente de OData se hospeda dentro de un Servicio de datos de WCF. Este servicio WCF hospedado por IIS en una aplicación web.
Los pasos siguientes crean un nuevo servicio de datos de WCF de ASP.NET.
Para crear la aplicación de servicio de datos de WCF
En Visual Studio 2012, en el menú archivo, elija nuevo, proyecto.
En el cuadro de diálogo Nuevo proyecto, en el nodo Visual C#, elija la plantilla Web y, a continuación, elija Aplicación Web ASP.NET.
Escriba NorthwindService como el nombre del proyecto y, a continuación, elija Aceptar.
A continuación, usar al Asistente de Visual Studio, descubrir el esquema del origen de datos y usarla para crear un modelo de datos de entidad ADO.NET.
Para definir el modelo de datos
En el Explorador de soluciones, abra el menú contextual para el proyecto ASP.NET y elija Agregar nuevo elemento.
En el cuadro de diálogo Agregar nuevo elemento, elija la plantilla de datos y, a continuación, elija ADO.NET Entity Data Model.
El nombre del modelo de datos, escriba Northwind.edmx.
En Entity Data Model Wizard, elija Generar desde la base de datos y, a continuación, elija siguiente.
Conectar el modelo de datos a la base de datos mediante uno de los siguientes pasos:
Si no tiene una conexión de base de datos ya configurada, elija Nueva conexión y crear una nueva conexión. Para obtener más información, vea Cómo: crear conexiones a bases de datos de SQL Server. Esta instancia de SQL Server debe tener la base de datos de ejemplo Northwind adjunto. Elija siguiente.
o
Si tiene una conexión de base de datos ya configurada para conectarse a la base de datos Northwind, elija esa conexión de la lista de conexiones y, a continuación, elija siguiente.
En la última página del asistente, active las casillas de todas las tablas de la base de datos y, a continuación, desactive las casillas de vistas y procedimientos almacenados.
Seleccione el botón Finalizar para cerrar el asistente.
En el siguiente paso, se crea el servicio real que está hospedado en IIS que proporcionará los medios para tener acceso a datos externos a través de Representational State Transfer (REST).
Para crear el servicio de datos de WCF
En el Explorador de soluciones, abra el menú contextual para el proyecto ASP.NET y a continuación, elija Agregar nuevo elemento.
En el cuadro de diálogo Agregar nuevo elemento, elija WCF Data Service.
El nombre del servicio, escriba Northwind.
En el código del servicio de datos, en la definición de la clase que define el servicio de datos, reemplace el comentario
/* TODO: put your data source class name here */por el tipo que es el contenedor de entidades del modelo de datos, que en este caso esNorthwindEntities. La definición de clase debe tener un aspecto similar al siguiente.
public class Northwind : DataService<NorthwindEntities>
Para establecer la seguridad en el servicio
- Ahora debe modificar la seguridad para permitir el acceso a los datos desde la fuente por los consumidores externos de OData. Cuando se crea un servicio WCF, se deniega todo el acceso de forma predeterminada. Realice los cambios siguientes a la clase que acaba de crear.
config.SetEntitySetAccessRule("*", EntitySetRights.All);
config.SetServiceOperationAccessRule("*", ServiceOperationRights.All);
Creación de la operación de servicio de suscripción (opcional)
El servicio de WCF también se pueden codificar con un medio para controlar las solicitudes Subscribe y Unsubscribe de SharePoint. Si decide crear estos procedimientos almacenados personalizados para la aplicación de cada uno de ellos se controlarán mediante una operación de servicio.
Suscribirse: suscribirse la operación toma la solicitud enviada por SharePoint y recupera la dirección de entrega, el tipo de evento y la entidad. También tiene que generar un subscriptionId y, a continuación, registrar todos ellos en la tabla de base de datos.
/// 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;
}
Nota:
[!NOTA] Si SQL Server está configurado para la autenticación de Windows, intentará autenticar la solicitud con la identidad del grupo de aplicaciones. Asegúrese de que la cuenta configurada en el grupo de aplicaciones tiene derechos para leer y escribir en la base de datos.
Crear el servicio de sondeo
El servicio de sondeo es un servicio de Windows que es responsable de consultar la tabla de cambios y de crear y enviar notificaciones a SharePoint o SharePoint Online en la dirección de entrega específica.
A continuación, cree un nuevo proyecto de servicio de Windows que se va a registrar en el equipo host WCF. Una vez registrado el proyecto, puede ver el servicio en ejecución en Microsoft Management Console (MMC).
Para crear un nuevo proyecto
Abra Visual Studio 2012.
Cree un nuevo proyecto mediante la plantilla de servicio de Windows, el nombre del proyecto PollingServicey elija el botón Aceptar.
Cuando se crea el proyecto, abra el archivo PollingService.cs en la vista código.
Agregue el código siguiente en la clase recién creada.
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;
}
El siguiente paso es crear un archivo ejecutable que se pueden agregar a los servicios en ejecución en el equipo de OData.
Para compilar e implementar el servicio de sondeo
Presione F5 para compilar el proyecto.
Abra el símbolo del sistema para VS2012.
En el símbolo del sistema, navegue a la ubicación de salida del proyecto.
En el directorio Bin, busque el archivo PollingService.exe.
Escriba installutil PollingService.exe y presione ENTRAR.
Compruebe que el servicio está ejecutando los servicios de MMC.
Componentes necesarios de SharePoint
Para completar todo el sistema, se requieren los siguientes componentes en el servidor que ejecuta SharePoint.
Tipo de contenido externo: El tipo de contenido externo es, básicamente, una definición de XML de origen de datos externo. Para este escenario, usará las herramientas de autogeneración en Visual Studio 2012 para descubrir el origen de datos y crear el tipo de contenido externo automáticamente.
Receptor de eventos externo: El receptor de eventos remoto o externo es lo que hace que las acciones en los cambios de datos externos sean posibles en SharePoint. Puede crear receptores de eventos para las listas externas y de las entidades.
Un receptor de eventos que se crea para una lista externa es similar a otros receptores de eventos para las listas de SharePoint. Cree el código y adjuntarla a la lista. Cuando se realiza una acción en los datos que está representados por la lista, se ejecuta el receptor de eventos.
Un receptor de eventos para las entidades se ejecuta al igual que un receptor de eventos basada en listas, excepto que no es necesario que se va a adjuntar a una lista. Recibe las notificaciones de la misma forma, pero no necesita la interfaz que está asociada con el ejemplo de la lista. La ventaja de esto es que puede interceptar las notificaciones mediante programación y crear el código para realizar alguna acción. En este escenario, esa acción consiste en crear un nuevo registro en la lista de notificaciones
Lista de notificaciones: La lista de notificaciones es una simple lista de SharePoint que se usa para registrar las notificaciones recibidas desde el sistema externo. Para cada nuevo registro agregado al sistema externo, se crea un registro en la lista de notificaciones.
Configurar los componentes de SharePoint
Ahora que tiene el configuración del sistema externo, es hora de pasar a la creación de la otra mitad de la ecuación. Ahora va a crear los componentes que se pueden hospedar en SharePoint.
Para crear un nuevo proyecto de Visual Studio 2012
En Visual Studio 2012, elija Nuevo proyecto.
Elija la plantilla de proyecto de aplicación de SharePoint.
Office Developer Tools para Visual Studio 2013 agrega a un asistente de autogeneración que descubrirá el esquema de un origen de datos y, a continuación, crear un tipo de contenido externo desde que.
Para agregar un nuevo tipo de contenido externo
En el Explorador de soluciones, abra el menú contextual del proyecto y elija Agregar, Tipos de contenido para un origen de datos externo.
Se inicia el Asistente para la personalización de SharePoint, que se usa para generar el tipo de contenido externo automáticamente.
Para obtener más información sobre cómo crear tipos de contenido externo, vea How to: Create an external content type from an OData source in SharePoint (Cómo: Crear un tipo de contenido externo a partir de un origen de OData en SharePoint).
Ahora modificará el XML que se generó en el paso anterior para agregar un método para Subscribe. Esto permitirá que BCS se comunique con el sistema externo cuando alguien se suscriba para recibir una notificación sobre los cambios de datos externos.
Para agregar el método Subscribe al tipo de contenido externo XML
En Explorador de soluciones, busque el nuevo nodo denominado Tipos de contenido externo.
Busque el archivo Customers.ect y ábralo con un editor XML.
Desplácese hacia abajo hasta la parte inferior de la página y pegue el método siguiente en la
<Methods>sección .
<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>
Ahora agregará código de cliente para permitir que la lista se suscriba a las notificaciones de eventos.
Para agregar código al archivo App.js para iniciar la suscripción
- En la carpeta Scripts del proyecto de complemento de SharePoint, abra el archivo App.js . Pegue el siguiente método en el archivo.
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 el receptor de eventos con este script, debe crear un botón en la página Default.aspx del proyecto y llamar a SubscribeEntity() desde el método onclick().
- Abra la página Default.aspx y agregue el siguiente código HTML.
<input type="button" value="Subscribe" onclick="SubscribeEntity();"/>
Para que los eventos funcionen, también debe habilitar la lista de SharePoint para que acepte eventos externos. Para ello, active la característica Eventos externos.
A continuación se muestra un script que activará la característica mediante código de 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));
}
Al igual que con Suscribirse, agregará un botón a la página que activará la característica.
Agregue el siguiente código HTML a la página Default.aspx, justo debajo del botón Suscribirse .
<input type="button" value="EnableEventing" onclick="EnableEventing_Clicked();"" />
A continuación, para este escenario, debe agregar una lista de notificaciones que mostrará las notificaciones enviadas por el sistema externo.
Para agregar la lista de notificaciones
En Explorador de soluciones, abra el menú contextual del nombre del proyecto y elija Agregar.
Elija la plantilla Lista y asigne el nombre listNotificationList.
Para imitar un receptor de eventos registrado con SharePoint en la caché global de ensamblados, el ejemplo proporciona una aplicación de consola que comenzará a escuchar los cambios. Cuando recibe una notificación, agrega un elemento de lista a NotificationList.
Para iniciar el receptor de eventos de línea de comandos
Abra RemoteEventReceiverConsoleApp.
Abra el archivo Program.cs y cambie el nombre del equipo local (o el equipo donde se ejecutará el receptor de eventos).
Haga clic en el botón Inicio de Visual Studio para ejecutar la aplicación de consola.
Se abre una ventana de comandos, que indica que la aplicación se ha compilado correctamente y está escuchando notificaciones de cambio desde el sistema externo. Deje esta ventana abierta durante esta prueba.
Para implementar la aplicación en SharePoint
- Presione F5 con Visual Studio abierto para compilar e implementar la aplicación.
Prueba de la aplicación
Ahora puede ver la aplicación en acción.
Examine la aplicación para ver las distintas listas que representan los datos del sistema externo.
Haga clic en la lista Clientes .
Agregue un nuevo cliente.
Vea el nuevo elemento de lista que acaba de crear.
Vaya a la lista de notificaciones para ver que el sistema externo ha notificado a SharePoint un cambio en la tabla Customers.
Tenga en cuenta que el temporizador está configurado para enviar notificaciones cada minuto. Durante las pruebas, es posible que tenga que esperar un breve período antes de ver las notificaciones publicadas.