Blog del CIIN

Blog del Centro de Innovación en Integración de Cantabria

This Blog

Syndication

Search

Tags

Community

Email Notifications

Archives

Enlaces Recomendados

August 2011 - Artículos

SharePoint 2010: Nuevo Video Center for SharePoint 2010 Development!

La verdad, y ya lo he dicho en muchas ocasiones, es que con SharePoint 2010 no nos podemos quejar por falta de recursos para hacer extensible la plataforma mediante desarrollo. En este sentido, estos días ha visto la luz un nuevo centro de recursos que recopila una serie de videos sobre desarrollo tanto para SharePoint 2010 On-Premise como para SharePoint Online en Office 365. Se trata del Video Center | SharePoint Development al que podéis acceder desde este enlace: http://msdn.microsoft.com/en-us/sharepoint/hh298298.aspx

image

Publicado 31/8/2011 23:20 por Juan Carlos González Martín | con no comments

SharePoint 2010: Cambios a nivel de API con el SP1!

Siguiendo con la serie de artículos sobre novedades que incorpora el reciente service pack 1 (SP 1) de SharePoint 2010, en esta ocasión toca hablar sobre cambios (no muchos en este caso) a nivel de API. En este sentido, una buena referencia a partir de la cuál conocer la novedades es este post de Gary Lapointe: SharePoint 2010 SP1 Public API Changes.

SharePoint2010_thumb

Publicado 31/8/2011 2:20 por Juan Carlos González Martín | con no comments

SharePoint 2010: Personalización de la navegación (I)!

Uno de los elementos de un sitio de SharePoint que se puede personalizar de acuerdo a distintas técnicas es el menú de navegación vertical. En este primer artículo vamos a ver como se puede personalizar la navegación de un sitio mediante el modelo de objetos, vamos a utilizar un Feature Event Reciver:

  • En Visual Studio 2010 creamos un proyecto de tipo “Empty SharePoint Project” y elegimos como tipo de despliegue “Deploy as farm solution”.
  • Añadimos al proyecto una Feature que configuramos de forma que el ámbito de la misma sea “Web”.
  • Añadimos un Feature Event Receiver y añadimos una directiva using a Microsoft.SharePoint.Navigation.
  • Codificamos el método FeatureActivated() de la siguiente forma:
   1: public override void FeatureActivated(SPFeatureReceiverProperties properties)
   2: {
   3:     SPWeb spwWeb = (SPWeb)properties.Feature.Parent;
   4:     if (spwWeb != null)
   5:     {
   6:         SPNavigationNode spnNodo = null;
   7:         foreach (SPNavigationNode n in spwWeb.Navigation.QuickLaunch)
   8:         {
   9:             if (n.Title == "Aplicaciones")
  10:             {
  11:                 spnNodo = n; 
  12:                 break;
  13:             }
  14:         }
  15:         //Si no existe la sección...
  16:         if (spnNodo == null)
  17:         {
  18:             spnNodo = new SPNavigationNode("Aplicaciones","", false);
  19:             spwWeb.Navigation.QuickLaunch.AddAsFirst(spnNodo);
  20:         }
  21:         spnNodo.Children.AddAsFirst(
  22:             new SPNavigationNode(
  23:                 "Nóminas", 
  24:                 "Documentos%20compartidos/Aplicaciones.aspx", 
  25:                 false));
  26:     }
  27: }
  • Codificamos el método FeatureDeactivating() de la siguiente forma:
   1: public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
   2: {
   3:     SPWeb spwWeb = (SPWeb)properties.Feature.Parent;
   4:     if (spwWeb != null)
   5:     {
   6:         SPNavigationNode spnNodo = null;
   7:         foreach (SPNavigationNode n in spwWeb.Navigation.QuickLaunch)
   8:         {
   9:             if (n.Title == "Aplicaciones")
  10:             {
  11:                 spnNodo = n; 
  12:                 break;
  13:             }
  14:         }
  15:         if (spnNodo != null)
  16:         {
  17:             SPNavigationNode spnNodoHijo = null;
  18:             foreach (SPNavigationNode n in spnNodo.Children)
  19:             {
  20:                 if (n.Title == "Nóminas")
  21:                 {
  22:                     spnNodoHijo = n; 
  23:                     break;
  24:                 }
  25:             }
  26:             if (spnNodoHijo != null)
  27:             {
  28:                 spnNodoHijo .Delete();
  29:  
  30:                 if (spnNodo.Children.Count == 1)
  31:                 {
  32:                     spnNodo.Delete();
  33:                 }
  34:             }
  35:         }
  36:     }
  37: }
  • Comprobamos que el menú de navegación se ha personalizad de acuerdo al código anterior:
image image

 

Y hasta aquí llega este primer artículo sobre como personalizar la navegación de un sitio de SharePoint.

Publicado 30/8/2011 16:42 por Juan Carlos González Martín | con no comments

Office 365: Materiales sobre seguridad y privacidad!

Uno de los compromisos que Microsoft tiene con respecto a su plataforma de productividad en la nube, u Office 365, es la de garantizar la seguridad y privacidad de la información de los clientes que la utilicen. En este sentido, y de cara a tener claro como Microsoft garantiza el cumplimiento de seguridad y privacidad que se puede esperar, tenemos disponibles una serie de materiales en torno a estas cuestiones nada triviales:

  • Office 365 - Standard Response to Request for Information – Security and Privacy This white paper is aligned to the Cloud Security Alliance publication of a Cloud Control Matrix, to support customers in the evaluation of cloud services. The document provides our customers and internal Microsoft employees with detailed responses to the suggested principles put forth by the CSA then mapped to our ISO 27001 certification.
  • Microsoft Online Services Trust Center The trust center is an external site that provides our Office 365 customers with detailed information in simple terms about our commitments relating to privacy, security, and data handling.
  • Security in Office 365 White Paper The purpose of this paper is to provide an overview of the security practices and technology that support enterprise-level security in Microsoft Office 365 for businesses of all sizes.
  • Office 365 – Security Service DescriptionThis document provides information about security to customers in the standard form of a service description.
  • Office 365 Cloud Security Consideration Paper (To be posted here shortly) – This final paper is an expansion upon the Cloud Computing Security Considerations paper released almost a year ago by the Chief Security Advisor Team. It address cloud security considerations in an Office 365 environment and how to strike a balance between customers and Microsoft responsibilities.

Fuente: http://blogs.msdn.com/b/mvplead/archive/2011/07/07/security-and-privacy-support-reference-materials-for-office-365.aspx

Publicado 29/8/2011 22:31 por Juan Carlos González Martín | 1 comment(s)

Archivado en:

SharePoint 2010: Trabajo programático con listas de tipo encuesta (I)!

Una de las listas que se crea por defecto en un sitio de tipo “Sitio de grupo” de SharePoint 2010 es la de tipo encuesta que permite modelar de forma sencilla cuestionarios en los que se pueden definir preguntas de distintos tipos y se permite responder a la misma de forma secuencial. Como habréis deducido, este tipo de lista es un tanto especial lo que es un factor a tener en cuenta cuando queremos atacarla programáticamente (para explotar las respuestas a una encuesta por ejemplo). Sin embargo, como os demostraré el trabajo vía API con este tipo de listas es similar al que realizamos con otros tipos:

  • Creamos en nuestro sitio de trabajo una lista de tipo encuesta.
  • Añadimos un par de preguntas de tipo “Una línea de texto”.
  • Respondemos al menos una vez a la encuesta.
image image image
  • Nos vamos a Visual Studio 2010 y creamos un proyecto de tipo Aplicación de Consola. Añadimos una referencia a Microsoft.SharePoint.
  • Añadimos una directiva using a Microsoft.SharePoint.
  • Añadimos un método estático a Program.cs que nos permita recorrer las respuestas de la encuesta y mostrar la información por pantalla como sigue:
   1: using System;
   2: using System.Collections.Generic;
   3: using System.Linq;
   4: using System.Text;
   5:  
   6: //Espacios de nombres necesarios
   7: using Microsoft.SharePoint;
   8: namespace SPEncuestasProc
   9: {
  10:     class Program
  11:     {
  12:         static void Main(string[] args)
  13:         {
  14:             ProcessSurvey();
  15:             Console.ReadLine();
  16:         }
  17:  
  18:         static void ProcessSurvey()
  19:         {
  20:             using (SPSite spsSitio = new SPSite("http://demo2010a:100/sites/PortalIntranet/"))
  21:             {
  22:                 using (SPWeb spwWeb = spsSitio.OpenWeb())
  23:                 {
  24:                     SPList splSurvey = spwWeb.Lists["Encuesta"];
  25:                     SPListItemCollection splicItemCollection = splSurvey.Items;
  26:                     int iInitialCount, iFieldsNumber, iAnswerNumber=0;                    
  27:                     foreach (SPListItem splItem in splicItemCollection)
  28:                     {
  29:                         Console.WriteLine("----Respuesta # {0} ----", iAnswerNumber);
  30:                        iFieldsNumber = splItem.Fields.Count;
  31:                        for (iInitialCount  = 0; iInitialCount < iFieldsNumber; iInitialCount++)
  32:                        {
  33:                            
  34:                            if (splItem[splItem.Fields[iInitialCount].InternalName]!=null)
  35:                            {
  36:                                Console.WriteLine(
  37:                                     splItem.Fields[iInitialCount].InternalName + " - " +
  38:                                     splItem[splItem.Fields[iInitialCount].InternalName]);    
  39:                            }                        
  40:                        }
  41:                        iAnswerNumber++;
  42:                     }
  43:                 }
  44:             }
  45:         }        
  46:     }
  47: }
  • Cómo veis, lo más interesante del método es la forma en la que se recorren todos los campos disponibles para un registro de la encuesta lo que nos permite acceder a las preguntas y a su respuesta. Esto lo conseguimos accediendo a la colección Fields disponible en cada objeto de tipo SPListItem de la lista.
  • Para cada campo, mostramos su nombre interno y su valor. La salida correspondiente por pantalla es la que se muestra a continuación:

image

Y hasta aquí llega este post sobre trabajo programático con listas de tipo encuesta.

Publicado 29/8/2011 6:05 por Juan Carlos González Martín | con no comments

SharePoint 2010: CSS Reference Chart!

Sin duda, a la hora de personalizar un sitio de SharePoint uno de los puntos claves a trabajar es el relativo a los estilos (CSSs) que tenemos que aplicar y sobre todo los estilos de SharePoint que queremos sobrescribir por lo que es muy importante tenerlos perfectamente localizados ya sea utilizando las herramientas de desarrollo del explorador web habitual de trabajo o bien consultando una excelente referencia creada por Heather Solomon: el CSS Reference Chart para SharePoint Foundation y SharePoint Server 2010 que recoge la mayoría de los estilos utilizados en ambos productos. Podéis acceder al CSS Reference Chart desde este enlace. Como podéis ver:

  • Los estilos se encuentran agrupados por categorías generales.
  • Para cada estilo se indica además de su identificador, el propósito del mismo y en que CSS se encuentra localizado (normalmente en el COREV4.css).

Sin duda un recurso imprescindible.

SharePoint2010_thumb

Publicado 28/8/2011 3:04 por Juan Carlos González Martín | con no comments

Office 365: ¿En cuántos equipos puedo instalar Office 2010 por cada suscripción?

Cómo sabéis, la suite de productividad de Microsoft en la nube Office 365 no sólo está formada por una serie de servicios que ofrecen capacidades de colaboración, comunicación, correo electrónico, mensajería instantánea, etc, sino que también incluye la posibilidad de usar la suite ofimática de Microsoft a través de la disponibilidad de Office 2010 Professional Plus. La novedad de disponer de esta suite es que no se necesita una clave de producto, sino que su uso se basa en el concepto de suscripción de Office 365. Ahora bien, una pregunta que nos puede venir a la cabeza es la de cuantas instalaciones de Office 2010 puedo realizar por suscripción. La respuesta es que 5 tal y como podéis encontrar en la siguiente referencia de TechNEt:  http://technet.microsoft.com/en-us/library/gg702619.aspx

image

Publicado 27/8/2011 5:04 por Juan Carlos González Martín | 1 comment(s)

Archivado en:

Office 365: Disponible el Productivity Hub para SharePoint Online!

Tal y como podéis leer en este post del blog de Ian Morrish, tenemos disponible una versión del Productivity Hub para SharePoint Online en Office 365. Esta versión complementa las ya existentes para SharePoint 2007 y SharePoint 2010 On-Premise y trata de proporcionar un entorno centralizado en el que definir actividades de formación en torno a productos de Microsoft usando las capacidades de social computing de SharePoint 2010 como blogs, grupos de discusiones, etc. En general, se trata de facilitar el acceso a estas tecnologías por parte del usuario final. Podéis descargaros el Productivity Hub desde este enlace.

082511_2135_SharePointP1[1]

Publicado 26/8/2011 8:34 por Juan Carlos González Martín | 1 comment(s)

Archivado en:

SharePoint 2010 & Azure: Integración de servicios mediante BCS (I)!

Una de las posibilidades que tenemos de integrar servicios WCF On-Premises o publicados en Azure es a través de los Business Connectivity Services (BCS) que facilitan el consumo de los mismos a través del correspondiente tipo de contenido externo (ECT) publicado en el catálogo de datos profesionales. A la hora de modelar estos ECTs tenemos dos posibilidades:

  • Utilizando SharePoint Desinger 2010 (SPD 2010).
  • Utilizando Visual STudio 2010.

En este primer artículo vamos a ver la primera de las posibilidades que nos permita consumir un servicio WCF On-Premise o publicado en Azure a través de un ECT creado con SPD 2010:

  • Lo primero que tenemos que hacer es disponer de un servicio ya publicado. En mi caso, el servicio a consumir tiene definida la siguiente lógica:
   1: using System;
   2: using System.Collections.Generic;
   3: using System.Linq;
   4: using System.Runtime.Serialization;
   5: using System.ServiceModel;
   6: using System.ServiceModel.Web;
   7: using System.Text;
   8:  
   9: namespace CustomerService
  10: {
  11:     // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "Service1" in code, svc and config file together.
  12:     // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "Service1" in code, svc and config file together.
  13:     public class CustomerService : ICustomerService
  14:     {
  15:         List<Customer> lCustomersList = new List<Customer>();
  16:  
  17:         /// <summary>
  18:         /// Gets the selelected customer
  19:         /// </summary>
  20:         /// <param name="sCustomerID">ID of the selected customer</param>
  21:         /// <returns></returns>
  22:         public List<Customer> getACustomer(string sCustomerID)
  23:         {
  24:             //Generate Customer Data
  25:             generateCustomerData();
  26:  
  27:  
  28:             //Querying the customer
  29:             var qCustomer = (from c in lCustomersList
  30:                              where c.IDCustomer == sCustomerID
  31:                              select c).ToList();
  32:             //Filling the returned data           
  33:             List<Customer> lrCustomer = qCustomer;
  34:  
  35:             return lrCustomer;
  36:         }
  37:  
  38:         public List<Customer> getAllCustomers()
  39:         {
  40:             generateCustomerData();
  41:             List<Customer> lAllCustomers = new List<Customer>();
  42:  
  43:             //Querying the customers
  44:             var qCustomers = (from c in lCustomersList
  45:                               select c).ToArray();
  46:             foreach (var qc in qCustomers)
  47:             {
  48:                 Customer tCustomer = new Customer();
  49:                 tCustomer.IDCustomer = qc.IDCustomer;
  50:                 tCustomer.sCustomerName = qc.sCustomerName;
  51:                 tCustomer.sCustomerAddress = qc.sCustomerAddress;
  52:                 tCustomer.sCustomerEMail = qc.sCustomerEMail;
  53:                 tCustomer.sCustomerPhone = qc.sCustomerPhone;
  54:  
  55:                 lAllCustomers.Add(tCustomer);
  56:             }
  57:  
  58:             return lAllCustomers;
  59:         }
  60:         /// <summary>
  61:         /// This method generates customer data for the service
  62:         /// </summary>
  63:         private void generateCustomerData()
  64:         {
  65:             Customer cCustomer1 = new Customer();
  66:             cCustomer1.IDCustomer = "1";
  67:             cCustomer1.sCustomerName = "Juan Carlos González";
  68:             cCustomer1.sCustomerAddress = "C/ Camilo Alonso Vega 41 7 D 39007 Santander";
  69:             cCustomer1.sCustomerEMail = "jgonzalez@gruposodercan.es";
  70:             cCustomer1.sCustomerPhone = "647 391 399";
  71:  
  72:             lCustomersList.Add(cCustomer1);
  73:  
  74:             Customer cCustomer2 = new Customer();
  75:             cCustomer2.IDCustomer = "2";
  76:             cCustomer2.sCustomerName = "Ángel Acha";
  77:             cCustomer2.sCustomerAddress = "C/ Joaquín Costa s/n 39005 Santander";
  78:             cCustomer2.sCustomerEMail = "aacha@gruposodercan.es";
  79:             cCustomer2.sCustomerPhone = "942 760 620";
  80:  
  81:             lCustomersList.Add(cCustomer2);
  82:         }
  83:     }
  84: }
  • La clase Customer que sirve como base en los tipos devueltos por getACustomer() y getAllCustomers() tiene la siguiente implementación:
   1: using System;
   2: using System.Collections.Generic;
   3: using System.Linq;
   4: using System.Web;
   5:  
   6: namespace CustomerService
   7: {
   8:     public class Customer
   9:     {
  10:         public string IDCustomer { get; set; }
  11:         public string sCustomerName{ get; set; }
  12:         public string sCustomerAddress { get; set; }
  13:         public string sCustomerEMail { get; set; }
  14:         public string sCustomerPhone { get; set; }
  15:     }
  16: }
  • Siendo ICustomerService la correspondiente interfaz en la que se definen tanto el contrato del servicio como las operaciones que implementa:
   1: using System;
   2: using System.Collections.Generic;
   3: using System.Linq;
   4: using System.Runtime.Serialization;
   5: using System.ServiceModel;
   6: using System.ServiceModel.Web;
   7: using System.Text;
   8:  
   9: namespace CustomerService
  10: {
  11:     // NOTE: You can use the "Rename" command on the "Refactor" menu to change the interface name "IService1" in both code and config file together.
  12:     [ServiceContract]
  13:     public interface ICustomerService
  14:     {
  15:  
  16:         [OperationContract]
  17:         List<Customer> getAllCustomers();
  18:         [OperationContract]
  19:         List<Customer> getACustomer(string sCustomerID);
  20:  
  21:       
  22:     }
  23:  
  24:  
  25:  
  26: }
  • Finalmente, el archivo web.config vital para que el servicio pueda ser consumido tiene la siguiente forma:
   1: <?xml version="1.0"?>
   2: <configuration>
   3:   <system.web>
   4:     <compilation debug="true" targetFramework="4.0" />
   5:   </system.web>
   6:     <system.serviceModel>
   7:         <services>
   8:             <service behaviorConfiguration="CustomerService.CustomerWCFServiceBehavior" name="CustomerService.CustomerService">
   9:                 <endpoint address="" binding="basicHttpBinding" contract="CustomerService.ICustomerService" />
  10:                 <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
  11:             </service>
  12:         </services>
  13:         <behaviors>
  14:             <serviceBehaviors>
  15:                 <behavior name="CustomerService.CustomerWCFServiceBehavior">
  16:                     <!-- To avoid disclosing metadata information, set the value below to false and remove the metadata endpoint above before deployment -->
  17:                     <serviceMetadata httpGetEnabled="true"/>
  18:                     <!-- To receive exception details in faults for debugging purposes, set the value below to true.  Set to false before deployment to avoid disclosing exception information -->
  19:                     <serviceDebug includeExceptionDetailInFaults="false"/>
  20:                     <useRequestHeadersForMetadataAddress>
  21:                         <defaultPorts>
  22:                             <add scheme="http" port="81"/>
  23:                             <add scheme="https" port="444"/>
  24:                         </defaultPorts>
  25:                     </useRequestHeadersForMetadataAddress>
  26:                 </behavior>
  27:             </serviceBehaviors>
  28:         </behaviors>
  29:         <serviceHostingEnvironment multipleSiteBindingsEnabled="true" />
  30:     </system.serviceModel>
  31:     <system.webServer>
  32:         <modules runAllManagedModulesForAllRequests="true"/>
  33:     </system.webServer>  
  34: </configuration>

Publicado el servicio ya sea On-Premise o en Azure, lo que necesitaremos para consumirlo en un ECT creado con SPD 2010 son las Urls del servicio y del WSDL:

image image image
  • En la configuración de la conexión al servicio WCF tendremos que especificar tanto la URL del WSDL como la del propio servicio. Especificaremos además un nombre para la conexión.
  • Como veis, la configuración difiere ligeramente en el caso de que el servicio esté publicado en Azure con respecto a si está publicado On-Premise.
  • Una vez establecida la conexión, se muestran los dos métodos disponibles que nos permitirán definir las operaciones básicas del ECT que consume el servicio.
image image image
  • Comenzamos con la operación “Leer lista” a partir del método getAllCustomers().
  • En la primera pantalla del asistentes especificamos el nombre de la operación y pulsamos “Siguiente”.
  • Pulsamos de nuevo “Siguiente”.
image image image
  • En la siguiente pantalla configuramos los parámetros de retorno de la operación. Lo más importante aquí es definir el identificador de la operación y el campo a mostrar en el selector de datos externos. Además, podremos parametrizar el nombre para mostrar en cada campo. Pulsamos Finalizar para que la primera operación quede definida.
  • Lo siguiente que haremos es definir la operación “Leer elemento”.
  • Como antes, en la primera pantalla del asistente de configuración de la operación especificamos un nombre para la misma y pulsamos “Siguiente”.
image image image
  • De nuevo definimos el identificador de la operación que en este caso es aún más importante ya que nos permite devolver una única entidad.
  • Configuramos de nuevo los parámetros de retorno y pulsamos “Finalizar”.
  • Guardamos todos los cambios realizados para que el ECT se refleje en el catálogo de datos profesionales y pulsamos la opción “Crear listas y formularios” para proceder a crear la correspondiente lista externa.
image image image
  • En la ventana de definición de la lista especificamos el nombre de la misma y si vamos a usar formularios InfoPath. Pulsamos “Aceptar” para que se cree la lista externa.
  • Navegamos al sitio de trabajo y comprobamos que en la lista creada se muestran los datos expuestos por el servicio.
  • Editamos un registro y comprobamos que se visualiza sin problemas.
image image image

Y hasta aquí llega este primer post sobre la integración de servicios mediante BCS y SPD 2010.

Publicado 25/8/2011 12:05 por Juan Carlos González Martín | 3 comment(s)

SharePoint 2010: ¿Y cuánto me cuesta?

Una pregunta más que recurrente en torno a SharePoint 2010 es la relativa a los costes de licenciamiento en función del despliegue que se necesite de nuestro servidor favorito. Por suerte, y a pesar de lo complicado que es el modelo de licenciamiento de Microsoft, tenemos algunos recursos en los que apoyarnos para intentar atinar en lo que va a costar un cierto despliegue de SharePoint:

SharePoint2010_thumb

Publicado 24/8/2011 22:38 por Juan Carlos González Martín | 2 comment(s)

Archivado en:

SharePoint 2010: Listado de build numbers!

Un tema siempre recurrente es el relativo a las versión actual (y también las versiones previas) que tengo instalada de SharePoint y que tiene que ser la misma para todos los servidores que forman parte de nuestra granja. Estos build numbers también pueden ser importantes en los pases a producción ya que si son diferentes en desarrollo y pre-produccion con respecto a producción, podremos encontrarnos con sorpresas no esperadas. Para conocer los build numbers que han ido apareciendo desde la RTM de SharePoint 2010 incluyendo cumulative updates (CUs), hotfixes y service packs os recomiendo este listado que Todd Klindt ha creado en su blog. Como comenta Todd en su blog, para ver la versión actual de SharePoint instalada en nuestro blog tenemos al menos las siguientes opciones:

  • Mediante la interfaz de usuario y la Administración Central de SharePoint siguiendo la ruta Configuración del sistema –> Administrar servidores en este conjunto de servidores. A continuación se muestra la página con el detalle de los servidores (http://demo2010a:2010/_admin/FarmServers.aspx) en la que podemos ver el número de Build Actual (en mi caso el SP1).
  • Mediante PowerShell y el comando Get-SPFarm
image image image
  • Y a estas opciones añado la API de SharePoint (en concreto usaremos la clase SPFarm) de acuerdo al siguiente código en un proyecto de tipo aplicación de consola:
   1: using System;
   2: using System.Collections.Generic;
   3: using System.Linq;
   4: using System.Text;
   5:  
   6: using Microsoft.SharePoint;
   7: using Microsoft.SharePoint.Administration;
   8:  
   9: namespace SPFarmDemo
  10: {
  11:     class Program
  12:     {
  13:         static void Main(string[] args)
  14:         {
  15:             SPFarm spfGranja = SPFarm.Local;
  16:             string sConfigDBName = spfGranja.DisplayName;
  17:             string sBuildVersion = spfGranja.BuildVersion.ToString();
  18:             Console.WriteLine("La BD de configuración {0} tiene el siguiente Build Version: {1}",
  19:                 sConfigDBName, sBuildVersion);
  20:             Console.ReadLine();
  21:         }
  22:     }
  23: }
  • La correspondiente salida por pantalla es la siguiente:

image

Publicado 23/8/2011 23:34 por Juan Carlos González Martín | 1 comment(s)

Office 365: Como realizar solicitudes de soporte técnico!

Cuando estamos trabajando con cualquiera de los servicios incluidos en Office 365, nos podemos encontrar con problemas en los mismos que únicamente se pueden solucionar a través del servicio de soporte técnico disponible en nuestro portal de administración:

  • Bajo la sección Soporte técnico del menú vertical se muestran las distintas opciones disponibles tanto para crear nuevas solicitudes de soporte como para ver el estado de las que ya tenemos abiertas.
  • Si pulsamos el enlace “Introducción”, accederemos a un panel en el que se muestra de forma resumida esta información y desde el que podremos acceder a la sección de soporte de la propia comunidad de Office 365 o bien acceder a una serie de soluciones rápidas a problemas comunes como por ejemplo es el cambio de contraseña de un usuario.
  • Para crear una nueva solicitud de soporte, pulsamos sobre el enlace “Preguntar a un agente de soporte virtual” de forma que se abre una ventanita en la que o bien podemos realizar consultas o bien acceder a información básica como por ejemplo el teléfono de soporte que muchas veces es más efectivo que el contacto por e-mail o las respuestas del agente de soporte virtual.
image image image

Publicado 23/8/2011 8:50 por Juan Carlos González Martín | 1 comment(s)

Archivado en:

SharePoint 2010: Como crear una vista de lista programáticamente!

El otro día comentaba en este post como añadir programáticamente una WebPart a una página de un sitio de SharePoint. En concreto, en el ejemplo mostraba como añadir una WebPart de tipo XsltListViewWebPart con la que he estado experimentando estos días…y he de decir que la flexibilidad que tiene para configurarla por programa es bastante potente. De hecho, en este post vamos a ver como crear una vista de lista programáticamente y como usarla luego en una XsltListViewWebPart que añadiremos  a una página del sitio de trabajo:

  • En Visual Studio 2010 creamos un proyecto de tipo aplicación de consola (también podría servirnos uno de tipo “Empty SharePoint Project” al que luego le añadiríamos la correspondiente Feature con su Feature Event Receiver).
  • Añadimos referencias a Microsoft.SharePoint y System.Web.
  • Al archivo Program.cs le añadimos las siguientes directivas using:
   1: using Microsoft.SharePoint;
   2: using SPWebPartPages = Microsoft.SharePoint.WebPartPages;
   3: using System.Web.UI.WebControls.WebParts;
  • Creamos un método estático que nos permita crear la vista de una lista del sitio, configurarla de forma adecuada y usarla como fuente de datos de una XsltListViewWebPart que añadiremos posteriormente a una página existente.
   1: static void AddWebPart()
   2: {
   3:     SPSite spsSitio=new SPSite("http://demo2010a:100/sites/PortalIntranet");            
   4:     SPWeb spwWeb = spsSitio.OpenWeb();
   5:  
   6:     SPList splLista = 
   7:         spwWeb.Lists["Documentos Compartidos"];
   8:                 
   9:     //Creación de la nueva vista            
  10:     splLista.Views[splLista.DefaultView.ID].Clone(
  11:         "Vista personalizada", 10, true, false);
  12:     //Modificación de la vista
  13:     SPView spVista = splLista.Views["Vista personalizada"];            
  14:     spVista.Title = "Vista personalizada";            
  15:     spVista.ViewFields.Delete("Modified");
  16:     spVista.Update();
  17:  
  18:     //Configuración de la XsltListViewWebPart
  19:     SPWebPartPages.XsltListViewWebPart xsltvwListViewWebPart =
  20:     new SPWebPartPages.XsltListViewWebPart();               
  21:     xsltvwListViewWebPart.ListId = splLista.ID;
  22:     xsltvwListViewWebPart.ViewGuid =
  23:         splLista.Views["Vista personalizada"].ID.ToString();
  24:     xsltvwListViewWebPart.Title = 
  25:         splLista.Views["Vista personalizada"].Title;
  26:     xsltvwListViewWebPart.AllowConnect = true;
  27:     xsltvwListViewWebPart.AllowEdit = true;
  28:     xsltvwListViewWebPart.AllowHide = false;
  29:     xsltvwListViewWebPart.AllowMinimize = false;       
  30:  
  31:  
  32:     //Añadiendo la WebPart a la página
  33:     SPWebPartPages.SPLimitedWebPartManager spwpmWebPartManager =
  34:         spwWeb.GetLimitedWebPartManager("SitePages/XsltListViewTest.aspx",
  35:             PersonalizationScope.Shared);
  36:  
  37:     spwpmWebPartManager.AddWebPart(xsltvwListViewWebPart, "Zone 1", 0);
  38:     spwpmWebPartManager.Dispose();
  39:     spwWeb.Dispose();
  40:     spsSitio.Dispose();
  41: }
  • Como vemos, creamos una vista de la biblioteca “Documentos Compartidos” utilizando el método Clone(). A continuación creamos un instancia de SPView a partir de la vista creada y al configuramos según necesitemos. En mi caso, he quitado la columna “Modified”. A partir de aquí, simplemente se crea una instancia de XsltListViewWebPart que se configura de acuerdo a esta vista y se añade a una página el sitio.
  • Ejecutamos el código y comprobamos que en la página añadida se muestra la vista creada.
image image
  • Finalmente, os dejo el código necesario para eliminar la WebPart de la página y la vista creada en la lista.
   1: static void DeleteWebPart()
   2: {
   3:     SPSite spsSitio = 
   4:         new SPSite("http://demo2010a:100/sites/PortalIntranet");
   5:     SPWeb spwWeb = spsSitio.OpenWeb();
   6:     SPWebPartPages.SPLimitedWebPartManager spwpmWebPartManager =
   7:         spwWeb.GetLimitedWebPartManager("SitePages/XsltListViewTest.aspx",
   8:             PersonalizationScope.Shared);
   9:     foreach (SPWebPartPages.WebPart spWebPart in spwpmWebPartManager.WebParts)
  10:     {
  11:         if (spWebPart.Title == "Vista personalizada")
  12:         {
  13:             spwpmWebPartManager.DeleteWebPart(spWebPart);
  14:             spwpmWebPartManager.Dispose();
  15:             break;
  16:         }
  17:     }
  18:     SPList splLista =
  19:         spwWeb.Lists["Documentos Compartidos"];
  20:     foreach (SPView spVista in splLista.Views)
  21:     {
  22:         if (spVista.Title == "Vista personalizada")
  23:         {
  24:             splLista.Views.Delete(spVista.ID);
  25:             break;
  26:         }
  27:     }
  28:  
  29:     spsSitio.Dispose();
  30:     spwWeb.Dispose();
  31: }

Y hasta aquí llega este artículo sobre como crear vistas de lista de forma programática.

Publicado 22/8/2011 20:31 por Juan Carlos González Martín | 1 comment(s)

SharePoint 2010: Listado de Permission strings!

SharePoint 2010 (también la versión anterior) utiliza cadenas de permisos o derechos que permiten que el usuario pueda acceder o no a ciertas acciones en función de si pertenece a un grupo cuyo nivel de permisos asociados contiene la cadena de permisos que se ha utilizado para las mismas. Esto sucede por ejemplo en el menú “Acciones del sitio” y lo podemos utilizar en nuestras personalizaciones de SharePoint para mostrar o no ciertos componentes de SharePoint utilizando un SPSecurityTrimmedControl que por ejemplo envuelva la Ribbon de SharePoint 2010, los accesos directo a la papelera de reciclaje y a la página de todo el contenido del sitio, etc. Para saber que cadenas de permisos o derechos tenemos disponibles, no tenemos más que visitar la correspondiente sección de MSDN en el que se listan. Como veis, al final estamos hablando de una enumeración que define dichas cadenas. Finalmente, os dejo otros enlaces relacionados con este concepto:

SharePoint2010_thumb

Publicado 21/8/2011 22:28 por Juan Carlos González Martín | 1 comment(s)

ADO.NET EF: Aplicaciones de ejemplo de las que partir!

Sin duda, cuando se está iniciando la inmersión en una tecnología en la que no se tiene experiencia es muy recomendable disponer de una serie de ejemplos iniciales de los que partir que faciliten su aprendizaje. En este sentido, y para el caso de ADO.NET Entity Framework, en MSDN disponemos de varias aplicaciones de ejemplo que permiten evaluar las posibilidades que brinda esta tecnología para el acceso a datos. Los ejemplos disponibles son los siguientes:

Podremos descargar estos ejemplos desde el siguiente enlace: Entity Framework Documentation Samples

Publicado 21/8/2011 15:31 por Juan Carlos González Martín | con no comments

Office 365: Por donde empezar!

Sin duda, a la hora de comenzar a trabajar con la suite de productividad de Microsoft en la nube o Office 365, nos surgirán una serie de cuestiones y dudas para los que toda referencia o soporte será bienvenido. En este sentido, es más que recomendable el siguiente post publicado en el blog técnico de Office 365 desde el que podréis acceder a los siguientes recursos:

image

Publicado 20/8/2011 15:49 por Juan Carlos González Martín | 1 comment(s)

Archivado en:

Office 365: Migración manual desde BPOS!

Cuando llevamos ya casi dos meses desde que Office 365 viera la luz, una pregunta cada vez más habitual es sobre la migración desde la versión previa de la plataforma de productividad en la nube de Microsoft (BPOS – Business Productivity Online Suite) a Office 365. El compromiso de Microsoft es que esta migración o transición será realizada de forma transparente y automática para el usuario a partir de septiembre…ahora bien, tal y como se comenta en este post del blog del equipo de Microsoft Onliune Services es posible realizar esta migración desde ta de forma manual aunque se recomienda esperar a que Microsoft haga la migración automática para evitarnos problemas y situaciones como los comentados en dicho post. Podéis leer más información sobre esta recomendación en este otro enlace.

image

Publicado 19/8/2011 20:14 por Juan Carlos González Martín | 1 comment(s)

Archivado en:

Patterns & Practices: Libros de adopción de Windows Azure!

Para facilitar la adopción de la plataforma Windows Azure, el equipo de Pattersn & Practices de Microsoft acaba de liberar una serie de libros en las que se cubren una serie de temáticas pensadas para esta tarea. Los libros publicados son los siguientes:

Más detalles en este post del blog del equipo de Windows Azure.

image

Publicado 18/8/2011 11:41 por Juan Carlos González Martín | con no comments

Archivado en:

SharePoint 2010: Cómo añadir una WebPart programáticamente a una página!

Una de las posibilidades de las que disponemos, como casi siempre, a la hora de añadir una WebPart a una página es la de hacerlo de forma programática. El proceso es tan sencillo como:

  • Crear un proyecto de tipo “Empty SharePoint Project” en Visual Studio 2010.
  • Añadir una Feature al proyecto a través del explorador de soluciones. A través del diseñador de características de Visual Studio 2010, configuramos de forma adecuada las propiedades de la misma.
  • Añadir un Feature Event Receiver a la característica partiendo de nuevo del explorador de soluciones, seleccionando la feature y pulsando la opción correspondiente disponible en el menú contextual.
image image
  • Añadimos una referencia a System.Web y pasamos a codificarlo añadiendo las siguientes directivas using:
   1: //Espacios de nombres necesarios
   2: using SPWebPartPages= Microsoft.SharePoint.WebPartPages;
   3: using System.Web.UI.WebControls.WebParts;
   4: using System.Collections.Generic;
  • Descomentamos el método FeatureActivated() y lo codificamos como sigue:
   1: public override void FeatureActivated(SPFeatureReceiverProperties properties)
   2: {
   3:     SPWeb spwWeb = (SPWeb)properties.Feature.Parent;
   4:     //Lista a mostrar en la XsltListViewWebPart
   5:     SPList splLista = spwWeb.Lists["Documentos Compartidos"];
   6:  
   7:     //Configuración de la XsltListViewWebPart
   8:     SPWebPartPages.XsltListViewWebPart xsltvwListViewWebPart =
   9:         new SPWebPartPages.XsltListViewWebPart();
  10:     xsltvwListViewWebPart.ListId = splLista.ID;
  11:     xsltvwListViewWebPart.ViewGuid =
  12:         splLista.DefaultView.ID.ToString();
  13:     xsltvwListViewWebPart.Title = "Documentos Compartidos";
  14:     xsltvwListViewWebPart.AllowConnect = true;
  15:     xsltvwListViewWebPart.AllowEdit = true;
  16:     xsltvwListViewWebPart.AllowHide = false;
  17:     xsltvwListViewWebPart.AllowMinimize = false;
  18:         
  19:     //Añadiendo la WebPart a la página
  20:     SPWebPartPages.SPLimitedWebPartManager spwpmWebPartManager =
  21:         spwWeb.GetLimitedWebPartManager("SitePages/WebPartsTest.aspx", 
  22:             PersonalizationScope.Shared);
  23:  
  24:     spwpmWebPartManager.AddWebPart(xsltvwListViewWebPart, "Zone 1", 0);
  25:     spwpmWebPartManager.Dispose();
  26: }
   1: public override void FeatureDeactivating(SPFeatureReceiverProperties properties)
   2: {
   3:     SPWeb spwWeb=(SPWeb)properties.Feature.Parent;
   4:     SPWebPartPages.SPLimitedWebPartManager spwpmWebPartManager =
   5:         spwWeb.GetLimitedWebPartManager("SitePages/WebPartsTest.aspx",
   6:             PersonalizationScope.Shared);
   7:     foreach (SPWebPartPages.WebPart spWebPart in spwpmWebPartManager.WebParts)
   8:     {
   9:         if (spWebPart.Title == "Documentos Compartidos")
  10:         {
  11:             spwpmWebPartManager.DeleteWebPart(spWebPart);
  12:             spwpmWebPartManager.Dispose();
  13:             break;
  14:         }
  15:     }
  16: }
  • En este caso, el objeto de tipo SPWebPartManager nos permite acceder a la colección de WebParts disponible en la página y eliminar aquella que cumpla la condición que hemos añadido.
  • Desplegamos el proyecto desde Visual Studio 2010 y comprobamos que en la página especificada (SitePages/WebPartTest.aspx) se muestra la WebPart añadida. Si desactivamos la feature, comprobaremos que la WebPart ya no se muestra.

image

 

Finalmente os dejo un enlace sobre como hacer lo mismo, pero utilizando PowerShell:http://farhanfaiz.wordpress.com/2011/07/25/sharepoint-2010-powershell-script-to-add-display-list-as-webpart.

Publicado 17/8/2011 21:54 por Juan Carlos González Martín | 1 comment(s)

SharePoint 2010: Integración con SSRS Denali (I)!

Como sabéis, desde hace unos días tenemos disponible la CTP3 de SQL Server Denali una de cuyas novedades más importantes es las novedades que trae en lo que a integración de Reporting Services con SharePoint se refiere. Si queréis ver estas novedades, es necesario que sigáis una serie de pasos relativos a como configurar esta integración. Por suerte, ya tenemos varios recursos relativos a como configurar la integración de Reporting Services de SQL Server Denali con SharePoint 2010:

SharePoint2010_thumb

Publicado 16/8/2011 19:01 por Juan Carlos González Martín | 1 comment(s)

Más artículos Página siguiente >