SharePoint 2010: Integración con SQL Azure (III)!

Siguiendo con la serie de artículos de integración entre SharePoint 2010 y SQL Azure, en esta ocasión vamos a dar un paso más y vamos a ver como realizar esta integración aprovechando la aplicación de servicio Business Connectivity Services (BCS) de SharePoint que permite integrar datos externos en SharePoint de forma sencilla y que en Visual Studio 2010 disponemos de una plantilla para crear modelos de Business Data Connectivity (BDC) para modelar dicha integración. Antes de empezar, os recuerdo los artículos previos relativos a la integración entre SharePoint 2010 y SQL Server Azure:

Como en artículos previos, partiremos de una BD creada en SQL Server Azure:

  • Iniciamos Visual Studio 2010 y creamos un proyecto de tipo “Emtpy SharePoint Project”.
  • Le añadimos al proyecto un elemento de tipo Business Data Connectivity Model.
  • Renombramos la entidad por defecto Entity1 a Store, el identificador de la misma a StoreID y los métodos ReadItem y ReadList a ReadStore y ReadStores respectivamente.
  • Realizamos los cambios necesarios a través del BDC Explorer para que cumpla lo siguiente (empezamos por el tipo devuelto por el método ReadStores):
    • El Type Name para la entidad Store tiene que ser de la forma “SQLAzureBCSDemo.Stores.Store, Stores”, es decir, al renombrar Entity1 por Store hay que tener cuidado de que dicho cambio se arrastre en las distintas propiedades del modelo.
    • El Type Descriptor  StoreID tiene que tener un Type Name de tipo Int32 y no de tipo String (valor por defecto) y hay que tener cuidado de cambiarlo en aquellos lugares dónde aparezca.
    • Añadimos varios Type Descriptors como campos de la tabla de la BD de SQL Azure queramos integrar mediante el BCS de SharePoint 2010.
  • Una vez que tenemos modelada la entidad Store, simplemente hacemos un copy de la misma para poder usarla como tipo devuelto por el método ReadStore() del modelo. Aquí verificamos que el Type Name para el parámetro de entrada es Int32.
image image image
  image  
  • Guardamos los cambios realizados en el modelo y nos vamos a la vista de explorador del proyecto para empezar con la lógica asociada. Lo primero que tenemos que hacer es modelar de forma correcta la clase Store de acuerdo a los Type Descriptor que hemos configurado en el BDC Explorer.
   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5:  

   6: namespace SQLAzureBCSDemo.Stores

   7: {

   8:     /// <summary>

   9:     /// This class contains the properties for Entity1. The properties keep the data for Entity1.

  10:     /// If you want to rename the class, don't forget to rename the entity in the model xml as well.

  11:     /// </summary>

  12:     public partial class Store

  13:     {

  14:         //TODO: Implement additional properties here. The property Message is just a sample how a property could look like.

  15:         public int StoreID { get; set; }

  16:         public string StoreTitle { get; set; }

  17:         public string StoreName { get; set; }

  18:         public string StoreAddress { get; set; }

  19:         public string StorePhone { get; set; }

  20:         public string StoreLatitude { get; set; }

  21:         public string StoreLongitude { get; set; }

  22:         public string StoreHours { get; set; }

  23:     }

  24: }

  • Siguiendo la filosofía del último artículo sobre la integración de SharePoint y SQL Azure, añadimos dentro del SPI del Bussiness Data Connectivity Model un elemento de tipo LINQ To SQL que nos va  a permitir integrarnos de forma sencilla con la BD SQL Azure.
  • Editamos la clase StoreService en la que tenemos que implementar los métodos ReadStore() y ReadStores() necesarios para poder consumir los datos de la BD SQL Azure a través del modelo LINQ To SQL. Como véis, la implementación con LINQ To SQL es bastante sencilla:
   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5:  

   6: using SQLAzureBCSDemo.Stores;

   7:  

   8: namespace SQLAzureBCSDemo.Stores

   9: {

  10:     public partial class StoreService

  11:     {

  12:         public static IEnumerable<Store> ReadStores()

  13:         {

  14:             using (SQLAzureStoresDataContext ctx =

  15:                 new SQLAzureStoresDataContext(

  16:                     "Server=tcp:<Server>.database.windows.net;Database=<BD>;User ID=<User>;Password=<Password>;Trusted_Connection=False;Encrypt=True;"))

  17:             {

  18:  

  19:                 var qStores = from s in ctx.StoreInformations

  20:                              select new{

  21:                                  SID=s.StoreID,

  22:                                  STitle=s.Title,

  23:                                  SName=s.StoreName,

  24:                                  SAddress=s.StoreAddress,

  25:                                  SPhone=s.StorePhone,

  26:                                  SLatitude=s.Latitude,

  27:                                  SLongitude=s.Longitude,

  28:                                  SHours=s.Hours

  29:                              };

  30:  

  31:                 List<Store> cStores = new List<Store>();

  32:                 foreach (var qs in qStores)

  33:                 {

  34:                     Store cStore = new Store();

  35:                     cStore.StoreID = qs.SID;

  36:                     cStore.StoreTitle = qs.STitle;

  37:                     cStore.StoreName = qs.SName;

  38:                     cStore.StoreAddress = qs.SAddress;

  39:                     cStore.StorePhone = qs.SPhone;

  40:                     cStore.StoreLatitude = qs.SLatitude;

  41:                     cStore.StoreLongitude = qs.SLongitude;

  42:                     cStore.StoreHours = qs.SHours;

  43:                     cStores.Add(cStore);

  44:                 }

  45:                 return cStores;

  46:             }

  47:         }

  48:  

  49:         public static Store ReadStore(int id)

  50:         {

  51:             using (SQLAzureStoresDataContext ctx =

  52:                 new SQLAzureStoresDataContext(

  53:                     "Server=tcp:<Server>.database.windows.net;Database=<BD>;User ID=<User>;Password=<Password>;Trusted_Connection=False;Encrypt=True;"))

  54:             {

  55:  

  56:                 var qStores = from s in ctx.StoreInformations

  57:                               where s.StoreID == id

  58:                               select new

  59:                               {

  60:                                   SID = s.StoreID,

  61:                                   STitle = s.Title,

  62:                                   SName = s.StoreName,

  63:                                   SAddress = s.StoreAddress,

  64:                                   SPhone = s.StorePhone,

  65:                                   SLatitude = s.Latitude,

  66:                                   SLongitude = s.Longitude,

  67:                                   SHours = s.Hours

  68:                               };

  69:  

  70:  

  71:                 Store cStore = new Store();

  72:                 cStore.StoreID = qStores.First().SID;

  73:                 cStore.StoreTitle = qStores.First().STitle;

  74:                 cStore.StoreName = qStores.First().SName;

  75:                 cStore.StoreAddress = qStores.First().SAddress;

  76:                 cStore.StorePhone = qStores.First().SPhone;

  77:                 cStore.StoreLatitude = qStores.First().SLatitude;

  78:                 cStore.StoreLongitude = qStores.First().SLongitude;

  79:                 cStore.StoreHours = qStores.First().SHours;

  80:                 return cStore;

  81:             }

  82:         }

  83:     }

  84: }

  • Hacemos el despliegue de nuestro modelo a nuestro entorno de SharePoint
  • Nos vamos al sitio de trabajo y creamos una lista externa para comprobar que la integración funciona de forma correcta.
image image image
  image  

Y hasta aquí llega este tercer artículo sobre la integración de SharePoint 2010 y SQL Azure.

Publicado por

Juan Carlos González

Juan Carlos es Ingeniero de Telecomunicaciones por la Universidad de Valladolid y Diplomado en Ciencias Empresariales por la Universidad Oberta de Catalunya (UOC). Cuenta con más de 12 años de experiencia en tecnologías y plataformas de Microsoft diversas (SQL Server, Visual Studio, .NET Framework, etc.), aunque su trabajo diario gira en torno a SharePoint & Office 365. Juan Carlos es MVP de Office Servers & Services desde 2015 (anteriormente fue reconocido por Microsoft como MVP de Office 365 y MVP de SharePoint Server desde 2008 hasta 2015), coordinador del grupo de usuarios .NET de Cantabria (Nuberos.Net, www.nuberos.es), co-fundador y coordinador del Grupo de Usuarios de SharePoint de España (SUGES, www.suges.es), así como co-director de la revista gratuita en castellano sobre SharePoint CompartiMOSS (www.compartimoss.com). Hasta la fecha, ha publicado 8 libros sobre SharePoint & Office 365 y varios artículos en castellano y en inglés sobre ambas plataformas.

Un comentario en “SharePoint 2010: Integración con SQL Azure (III)!”

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *