Haaron Gonzalez : C#

Programación de WebParts de SharePoint 2010 con Visual Studio 2010, pan comido para un desarrollador .NET

Haaron Gonzalez — Tue, 23 Apr 2013 16:11:00 GMT

Tú como programador .NET seguramente has escuchado hablar de SharePoint y muy probablemente en las bolsas de trabajo encuentras que un plus en tu currículo como programador es saber SharePoint o programar en SharePoint. Bien, pues aquí tienes un video que publique en mi canal de YouTube donde como programador puedes conocer lo siguiente de SharePoint:

Que son los WebParts
Como están constituidos
Que elementos o clases usamos para construirlos
Como programarlos y con qué herramientas
Como empaquetarlos para su portabilidad

Date el tiempo ver este video, especialmente desde la demostración ya que se explica y se muestra lo básico de la construcción de un webpart, múltiples enfoques de empaquetamiento e incluso hasta el uso de AJAX.

Originalmente publicado en msmvps.com

Programando con Listas en Windows SharePoint Services 3.0

Haaron Gonzalez — Wed, 10 Apr 2013 19:59:00 GMT

Aquí un entrenamiento que di hace muchos años para una empresa en la que trabajé como líder de practica de colaboración. Básicamente preparé esta presentación para mostrar a programadores como manejar listas y elementos de forma programática a fin de introducirlos al mundo de la programación SharePoint.

Durante una revisión a un respaldo me encontré con los archivos fuente de este WebCast y decidí compilarlo como video para subirlo a mi canal de Youtube. Si por alguna razón sigues dando soporte a plataforma SharePoint 2007 (MOSS o WSS 3.0) en temas de programación este video sin duda es una referencia que te permitirá entender los fundamentos de programación de listas en SharePoint.

Además, creo que los temas aquí mencionados también aplican para SharePoint 2010 J

Originalmente publicado en msmvps.com

Análisis de Código para SharePoint Online

Haaron Gonzalez — Fri, 05 Apr 2013 05:39:00 GMT

Aún recuerdo FxCop como una de las primeras herramientas que teníamos disponibles los programadores .NET para revisar nuestro código y evaluarlo contra las practicas recomendadas y de esta forma poder mitigar potenciales riesgos de desempeño, seguridad, acceso a datos, etc. Desde el punto de vista de un programador SharePoint podemos utilizar herramientas para revisar nuestro código de la misma forma por ejemplo las herramientas de análisis de código de Team Foundation sin duda nos dan una información muy valiosa, pero, en el mundo SharePoint debido al modelo de objetos y a las diversas tecnologías disponibles sabemos que se tienen otras reglas de codificación o prácticas de programación adicionales a las de .NET y en ese sentido ¿no sería útil contar con una herramienta que te revisa el código SharePoint?

MICROSOFT SHAREPOINT ONLINE CODE ANALYSIS FRAMEWORK (MSOCAF)

Es una herramienta de revisión y diagnóstico de código de programación de soluciones SharePoint que nos permite identificar inconsistencias de programación en distintas áreas para asegurar la calidad de nuestros desarrollos en ambientes o entornos compartidos. MSOCAF ofrece todo un proceso de revisión de soluciones, se utiliza para validar las soluciones de programación que se publican en SharePoint Online de Office 365 y que ahora tenemos disponible para revisar nuestras aplicaciones tanto para soluciones SharePoint Online 2010 y 2013.

Las reglas que revisa son:

Rule Tests Against
Use of SPList.Items
SPListItemCollection\GetItemByID inside loop
SPQuery without Row Limit property
SPQuery Row Limit value range
Timer jobs
Out-of-the-box files modification
Verbose logging \ tracing
Deprecated APIs
Editing Web config files
Inline code ASPX pages
SPListItem.Update() inside loop
SPMonitoredScope Web Part check*
SPDiagnostics Service
ULS logging
BlobCache value editing in web.config
RunWithElevatedPrivileges restrictions
SharePointQueryWebPartsCheck
Windows Claims Check

Así que no está nada mal poder incluir el uso de esta solución como parte del proceso de revisión de código de programación en nuestros equipos. Ahora, esta solución ha sido diseñada para Office 365 y SharePoint Online, sin embargo, desde mi muy particular opinión sí creo que nos da un soporte para revisar nuestras soluciones On Premise.

Sin más que decir por el momento aquí les dejo el enlace: https://caf.sharepoint.microsoftonline.com/

Originalmente publicado en msmvps.com

Validando la contraseña de las cuentas de una implementación SharePoint

Haaron Gonzalez — Thu, 31 Jan 2013 01:15:00 GMT

Me pidieron que validara las cuentas que utilizamos para instalar SharePoint en un ambiente de producción y pues la gente de la mesa de soporte al ver que mi petición no tiene tanta urgencia "según ellos" y conforme a sus acuerdos de niveles de servicio me informaron que en una semana me tendrían la respuesta a mi solicitud. El problema a solucionar es que no se sabía si la contraseña X era la misma que se usó en todas las cuentas de SharePoint, en total fueron 9 cuentas y dado que en una semana ni siquiera estaré aquí físicamente me vi en la necesidad de encontrar una solución alterna rápidamente.

Las cuentas a validar fueron:

POLLOLOCO\SP_farm
POLLOLOCO\SP_services
POLLOLOCO\SP_web
POLLOLOCO\SP_search
POLLOLOCO\SP_sync
POLLOLOCO\SP_superuser
POLLOLOCO\SP_superreader
POLLOLOCO\SP_crawl
POLLOLOCO\SP_unattended

Estimado lector, para solucionar tu problema, ¿qué harías si en algún momento de tu vida fuiste un apasionado programador .NET y sabes que puedes hacer al respecto?, ¿Te esperarías a que la gente de mesa de soporte de acuerdo a sus prioridades te responda?, ¿serias un radical y con el poder que el conocimiento te da resolverías tú mismo tus problemas, claro sin que muera nadie?

En mi caso decidí bajar Visual Studio 2012 Express for Windows Desktop y escribir una aplicación de consola que utilizando el namespace de System.DirectoryServices pudiese consultar el active directory en cuestión y validar las credenciales que necesito validar. En tan solo 12 minutos ya tenía mi instancia de Visual Studio 2012 Express for Windows Desktop instalada, durante la descarga busqué en internet y encontré que desde la versión 3.5 del .NET Framework se incluyó una nueva funcionalidad para gestión de active directory la cual se encuentra en System.DirectoryServices.AccountManagement y pues utilizando la clase PrincipalContext pude invocar el método ValidateCredentials con el cual sabría si la cuenta X o Y era válida.

El código lo comparto aquí:

using System;
using System.Text;
using System.DirectoryServices.AccountManagement;

namespace TestAccount
{

    class Program
    {

        static void Main(string[] args)
        {

            bool isValidAccount = false;

            Console.WriteLine("Domain Name (NetBios):");
            string domainName = Console.ReadLine();

            Console.WriteLine("User account:");
            string accountName = Console.ReadLine();

            Console.WriteLine("Password:");
            string accountPassword = Console.ReadLine();

            try
            {

                if (string.IsNullOrEmpty(domainName) || string.IsNullOrEmpty(accountName) || string.IsNullOrEmpty(accountPassword))
                    throw new ArgumentNullException();

                using (PrincipalContext context = new PrincipalContext(ContextType.Domain, domainName))
                {                    
                    isValidAccount = context.ValidateCredentials(accountName, accountPassword);
                }

                Console.WriteLine("{0}\\{1} - {2}",domainName, accountName, isValidAccount.ValidNotValidString());              
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: {0}",ex.Message);
            }
            finally
            { 
                Console.ReadKey(); 
            }       
            
        }
    }

    public static class BooleanExtensions
    {
        public static string ValidNotValidString(this bool value)
        {
            return value ? "Valid account" : "Not Valid account, check username or password!";
        }
    }
}

Y la solución aquí también la puedes encontrar en el attachment, dentro esta el ejecutable compilado.

PD. Cuando el equipo de la mesa de ayuda me contacte de 5 días, que le debería de decir en respuesta?

Saludos

Originalmente publicado en msmvps.com

Paquete de 101 códigos de ejemplo en desarrollo SharePoint 2010

Haaron Gonzalez — Wed, 22 Feb 2012 18:32:00 GMT

En el blog oficial del equipo de desarrollo SharePoint de Microsoft se ha publicado una entrada referente a un paquete de ejemplos de código sobre SharePoint 2010 lo cual me parece fabuloso. Estuve revisando la lista de ejemplos y se deja ver que este es un excelente recurso para programadores SharePoint y/o principiantes.

Puedes descárgalo aquí y estoy seguro será de utilidad

Originalmente publicado en msmvps.com

Excepción cuando trabajamos con DirectoryServices

Haaron Gonzalez — Thu, 25 Aug 2011 08:29:27 GMT

Algo que hoy descubrí con asombro es que cuando trabajamos con las clases de System.DirectoryServices en específico DirectoryEntry para hacer consultas en un directorio activo es importante pasar la ruta del servidor LDAP utilizando mayúsculas en la cadena.

Si, así es.

Si utilizamos la línea con letra minusculas:

DirectoryEntry de = new DirectoryEntry("ldap://litwaredc:389/CN=Users,DC=litwareinc,DC=com");

Surgirá una excepción de tipo COM. La dirección DN es correcta, solo que se necesita modificar la parte ldap por LDAP para que DirectoryEntry se digne a funcionar como se espera.

DirectoryEntry de = new DirectoryEntry(LDAP://litwaredc:389/CN=Users,DC=litwareinc,DC=com);

Seguro existe una razón, sin embargo que alguien me explique!

Originalmente publicado en msmvps.com

Usando los controles de SharePoint en WebParts

Haaron Gonzalez — Thu, 28 Jul 2011 17:30:00 GMT

Sin duda, con el poder viene la responsabilidad. En pasados días publiqué un post acerca de cómo utilizar los controles de ASP.NET y toda su experiencia gloria dentro de WebParts de SharePoint. Sin embargo, al utilizar esta estrategia un conjunto de consideraciones subsecuentes deberán ser contempladas como hacer uso de los mismos controles SharePoint dentro de estos WebParts.

En ese sentido, debido a que sin problema alguno puedo utilizar el GridView y/o cualquier control ASP.NET al principio suena atractiva la posibilidad pero como siempre la realidad se asoma y nos muestra al que un día fue novedoso control Calendar de ASP.NET y con todo el debido respeto, hoy no es la mejor opción para la captura de una fecha dentro de una forma en SharePoint, al menos la mejor opción es usar el mismo control que se usa en SharePoint, ¿estás de acuerdo?

Vamos a nuestro Web User Control y registramos los controles web de SharePoint. Estos son los controles mejorados que SharePoint internamente utiliza en su capa de presentación.

Después dentro de nuestro código Markup agregamos el control SharePoint que requerimos:

Lo interesante es que tenemos una gama de controles de SharePoint disponibles.

A continuación dentro del código hacemos referencia al control de SharePoint para poder adjuntar algún evento o leer su valor.

Y el resultado es:

Estos controles cuentan con validaciones, propiedades y eventos que podemos utilizar a nuestro favor. Créditos a Luis Edmundo Teos por el reto y escenario.

Suerte!

Originalmente publicado en msmvps.com

Cuantos ingenieros se necesitan para cambiar una bombilla o crear sitios SharePoint

Haaron Gonzalez — Thu, 31 Mar 2011 19:50:00 GMT

No es curioso, es un hecho que en el ambiente laboral relacionado con tecnologías de información y seguramente en muchos otros, nos encontramos con diversas personalidades, temperamentos y arquetipos colaborando día con día para resolver algún problema técnico o de negocio. Las personas tenemos toda una historia distinta, además de cualidades que en parte de forma consiente o inconsciente constituye la forma muy particular de ver y reaccionar ante vida, en algunos casos estas cualidades son las adecuadas para ciertos escenarios pero que en definitiva en otros no lo son.

Entonces la pregunta es, ¿cómo aprovechar lo que cada quien aporta para generar valor empresarial?, esa es una pregunta que especialistas en Management, Leadership y Coaching podrían responder sin ningún problema. Sin embargo, desde mi óptica por lo menos compartir constantemente una visión compartida con lineamientos claros es esencial para organizar y aprovechar lo que cada persona con su historia histeria y experiencia aporta.

En esta historia, el requerimiento es crear un conjunto finito de sitios con las siguientes características:

Cada sitio se basa en la plantilla de sitio de Trabajo en Equipo
Cada sitio no deberá tener herencia de permisos
Cada sitio deberá contar con 4 grupos “Owners, Visitors, Members, Permissions” bajo la nomenclatura “Sitio + Nombre de grupo”
Cada sitio cuenta con usuarios específicos para cada grupo.

Lo que piensan los miembros del equipo de TI:

Miembro 1 - Vamos a lucirnos con la solución, hagamos un WSP con feature receiver a nivel sitio web para que cuando le den activar en las características del sitio, programáticamente los construya y configure.
Miembro 2 – ¿Hay urgencia por parte del cliente como para dedicar tiempo a construir y probar un WSP?, ¿se va a reutilizar la jerarquía en algún otro sitio en el futuro?, ¿conviene dejar archivos en el 12 hive y un ensamblado en el GAC con full trust assembly?, ¿vamos a implementar en DEV, QA, UAT y PROD el WSP? Yo digo que construyamos los sitios manualmente usando el UI de SharePoint.
Miembro 3 – Usemos scripts en un archivos *.bat que ejecute el comando stsadm.exe para crear los sitios y grupos, pasamos parámetros e nivel comando y creamos un solo archivo que cuente con todas las instrucciones necesarias.

Después los miembros dan inicio a los argumentos técnico-personales para defender su postura a capa y espada, como si fueran program managers de microsoft, correos electrónicos empiezan a fluir con preguntas que toman minutos leer y escribir de regreso para ser enviados de nuevo. El tiempo pasa, el tema sube de nivel, siguen estancados, el usuario pregunta por sus sitios y en eso Miembro 2 lo toma personal, sube de nivel su contestación y claudica ante su postura. Miembro 1 ratifica la postura de Miembro 2 con el afán de no afectar al equipo y Miembro 3 procede a ejecutar la postura del Miembro 2. Tiempo total transcurrido 2.5 horas.

Si lo analizamos, todos pierden. El espíritu del equipo se deteriora, definitivamente se ve mal y el usuario de plano esperando. Realmente cualquier postura es aceptable y totalmente factible, cada una con sus peculiaridades, estimaciones, esfuerzos y consecuencias.

Dicho esto, tengo 2 preguntas:

¿Cómo podríamos contextualizar las cosas para asegurar que antes de dar inicio a una solución construida por ingenieros, todos estén viendo hacia el mismo lugar? Esa es una respuesta que probablemente podamos encontrar aquí http://www.crecenegocios.com/los-objetivos-de-una-empresa/
¿Qué estrategia técnica conviene utilizar para un escenario donde el resultado se requiere de inmediato? A veces me pregunto si mi trabajo es preguntar, sin embargo haciendo un intento de posible respuesta, dejo algunos cuestionamientos respecto al escenario planteado y claro, su implementación.

Construyendo sitios de forma manual

Pros

Rápida ejecución usando UI de SharePoint
Cero dependencia a código, ensamblado o XMLs, todo queda en la base de datos usando los site definitions y templates propietarios de SharePoint que si están considerados para ser migrados y respaldados

Cons

No es repetible
Requiere de intervención manual para replicar en cada ambiente y por lo tanto hay margen de error

Implementación

Ubicados en el sitio en cuestión accedemos a Acciones de sitio, Configuración del sitio, Toda la configuración del sitio y al de final las galerías elegimos crear sitios o área de trabajo. Especificamos el nombre, url y los siguientes puntos:

Crear sitio	Configurar grupos

Construyendo sitios programáticamente

Pros

Total portabilidad a múltiples ambientes y sitios con mínimo esfuerzo de implementación
Aprovisionamiento y des aprovisionamiento flexible de la funcionalidad y dependencias

Cons

Crea una dependencia a un WSP, ensamblado en GAC y archivos en 12 hive
Requiere de construcción, pruebas, empaquetamiento y puesta en marcha en cada ambiente
Pasa a control de versiones y gestión

Implementación

En este caso vemos que utilizamos una colección especial de tipo diccionario para almacenar la URL y Nombre del sitio que deseamos crear. Existen varias formas de hacer lo mismo, en este caso recorremos la colección de plantillas SharePoint para poder elegir la que usaremos “Team Sites”. Recorremos la colección de nuestro diccionario y utilizamos la colección Webs para agregar un nuevo site pasando los argumento recolectados, lo mas importante destacar en este punto es que el ultimo argumento false indica que no se mantiene la herencia y a continuación ya dentro del sitio rompemos la herencia, posteriormente recorremos el arreglo que tiene el nombre de los grupos que estaremos construyendo programáticamente, ese código se los debo y si alguien quiere compartirlo adelante.

           uint        lcid_english = 1033;
            string      siteUrl = "http://portal.litwareinc.com";
            string[]    groupTypeNames = {"Owners","Members","Permissions","Visitors"};

            Dictionary<string, string> targetSites = new Dictionary<string, string>();
            targetSites.Add("demo1", "Sitio de demostracion 1");
            targetSites.Add("demo2", "Sitio de demostracion 2");
            targetSites.Add("demo3", "Sitio de demostracion 3");
                    
                using (SPSite site = new SPSite(siteUrl))
                {
                    SPWebTemplate siteTemplate = null;
                    SPWebTemplateCollection templateCollection = site.GetWebTemplates(lcid_english);
                    
                    foreach (SPWebTemplate template in templateCollection)
                    {
                        if (template.Title.Equals("Team Site"))
                        {
                            siteTemplate = template; 
                            break;
                        }
                    }

                    using (SPWeb web = site.OpenWeb())
                    {
                        foreach (KeyValuePair<string, string> siteInfo in targetSites)
                        {
                            using (SPWeb newWeb = web.Webs.Add(

siteInfo.Key,

siteInfo.Value,

string.Empty,

lcid_english, siteTemplate, false, false))
                            {
                                newWeb.BreakRoleInheritance(false);
                                newWeb.Update();

                                foreach(string groupTypeName in groupTypeNames)
                                {
                                    string groupType = string.Format("{0} {1}",siteInfo.Value,groupTypeName);
                                    
                                    // aqui deberas crear el grupo y asignar los permisos         
                                }                                                                  
                            }                            
                        }
                    }                
                }

Construyendo sitios con comandos stsadm.exe

Pros

Reutilización moderada e intervención manual para especificar sites, groups que se aprovisionaran por los comandos
Fácil de corregir y reaccionar ante cualquier error
La forma recomendada por Microsoft

Cons

Crea una dependencia al script que ejecuta los comandos de staadm.exe para la estructura solicitada
Pasa a control de versiones y gestión

Implementación

En esta alternativa utilizamos las sentencias del comando stsadm.exe ubicado en c:\program files\common files\microsoft shared\web server extensions\12\bin especificando mediante –o la opción que deseamos y mediante los parámetros especificamos lo que requerimos. Específicamente –unique describe que no queremos heredar los permisos. Subrayo en rojo la parte donde especificamos el URL del sitio que estaremos creando. En este caso estamos creando un sitio llamado Sitio 1 y posteriormente creando cuatro grupos en donde los grupos Visitors y Members tienen como dueño al grupo Permissions.

stsadm.exe -o createweb –url "el url del sitio donde crearemos/url del nuevo sitio" -lcid 1033 -sitetemplate STS#0 -title "Sitio 1" -description "" –unique

stsadm.exe -o creategroup -url "el url del sitio donde aplicaremos" -name "Sitio 1 Permissions" -description "Permissions of the site" -ownerlogin "administrator@litwareinc.com" -type "Owner"

stsadm.exe -o creategroup -url "el url del sitio donde aplicaremos" -name "Sitio 1 Owners" -description "Owners of the site" -ownerlogin "administrator@litwareinc.com" -type "Owner"

stsadm.exe -o creategroup -url "el url del sitio donde aplicaremos" -name "Sitio 1 Visitors" -description "Visitors of the site" -ownerlogin "Sitio 1 Permissions" -type "Visitor"

stsadm.exe -o creategroup -url "el url del sitio donde aplicaremos" -name "Sitio 1 Members" -description "Members of the site" -ownerlogin "Sitio 1 Permissions" -type "Member"

Personalmente en ocasiones he llegado a pensar, ¿qué es mas complejo?, la tecnología o la psicología, en fin.

¿Cuál es la mejor alternativa? Depende

Originalmente publicado en msmvps.com

Desarrollo de WebParts de SharePoint 2010 con soporte AJAX

Haaron Gonzalez — Thu, 10 Jun 2010 10:52:00 GMT

Microsoft no se cansa de dar el mensaje de que SharePoint 2010 es una plataforma de aplicación aparte de una plataforma de colaboración para la empresa y la web. Y el día de hoy quiero mostrar un breve y sencillo ejemplo de cómo construir un WebPart para SharePoint 2010 con soporte AJAX.

Visual Studio 2010 por fin cuenta con un nuevo ciudadano de funcionalidad, se cuenta con toda una sección y plantillas de proyectos solo para la plataforma SharePoint 2010 soportada de forma nativamente y permitiendo a los programadores curiosos que no le temen al cambio adentrarse al mundo de desarrollo de SharePoint.

Este video muestra lo simple que es construir e implementar un WebPart para SharePoint 2010 con características de AJAX. Cero líneas de código de configuración, arrastrar, soltar, doble clic y a programar es parte del paradigma con el que contamos en esta nueva versión.

Desde mi personal punto de vista no hay nada mejor que saber que sucede tras bambalinas sin embargo en este mundo donde la economía y las empresas constantemente cambian y por ende las herramientas que simplifican las cosas para solamente dedicarnos a lo que nos compete desde el punto de vista de negocio y no necesariamente a aquellas cosas de configuración que al negocio prácticamente le es indiferente.

Aqui el video con mas resolucion:

Originalmente publicado en msmvps.com

Manipulación programática de archivos de Microsoft Project *.mpp con .NET

Haaron Gonzalez — Thu, 22 Apr 2010 18:20:00 GMT

Si por alguna extraña razón cósmica en este mundo ultra moderno de la programación de software bajo plataforma .NET te encuentras con la necesidad de manipular programáticamente archivos de Microsoft Office te recomiendo uses el proyecto open source MPXJ.

La biblioteca MPXJ permite la lectura y escritura de diversos formatos de archivo de Microsoft Project usando un API en .NET o Java. Estas API ofrecen clases que representan los componentes de un archivo de Project como Tareas, Recursos, Calendario, Asignaciones, etc. Y los métodos para poder acceder, operar y manipular dichos objetos.

Estoy seguro que este modelo de objetos te permitirá darte una idea de cómo inter operar con Project desde tus aplicativos. En mi caso, con la ayuda de @juankaram “que en definitiva fue estratégica su intervención”, tuvimos que integrar en SharePoint un WebPart lector de archivos de Project.

El resultado:

Originalmente publicado en msmvps.com

Como consumir lista de SharePoint 2010 en Windows Forms mediante REST

Haaron Gonzalez — Fri, 19 Feb 2010 21:19:00 GMT

En Microsoft uno de los puntos que se enorgullecen de divulgar es que ahora se soporta REST para acceso a listas y bibliotecas de documentos lo cual me parece fantástico ya que si aporta valor la alternativa de obtener acceso directo al contenido basado en un estándar y que sin tanto esfuerzo de programacion lo podamos lograr es tambien un tema a consiuderar. Este seguro que desde ya podemos ver muchas aplicaciones de esta característica en proyectos de desarrollo SharePoint.

Hagamos una breve y simple demostración de cómo consumir un servicio REST de SharePoint en una aplicacion Windows Forms.

Soporte REST en SharePoint 2010

Primeramente accedemos a nuestro sitio SharePoint 2010 y en la dirección URL hay que capturar “_vtn_bin/listdata.svc" el cual es un servicio WCF que se encarga de exponer el sitio entero en formato REST. Dependiendo del URL de nuestro sitio es el contenido que el servicio listdata.svc nos retorna.

Como puedes ver aquí tenemos en formato REST el contenido del sitio.

Mediante la URL indagamos y accedemos a los sub elementos de este esquema, por ejemplo si quisiéramos acceder a la lista de anuncios “Announcements” entonces modificamos el URL y capturamos subsecuentemente /_vti_bin/listdata.svc/Announcements arrojando lo siguiente:

El navegador lo interpreta y muestra como un Feed RSS sin embargo al ver el código fuente de esta página vemos más contenido de acuerdo a REST. Encontramos un esquema mucho mas explicito que describe y autocontiene la informacion invocada.

Lo único que debes de saber es que la dirección URL es sensible a mayúsculas y minúsculas de tal forma que debes de asegurarte de especificar exactamente igual el nombre de las listas y bibliotecas, no hay margen para el error aquí.

Consumiendo Servicio REST de SharePoint 2010

Debido a que REST opera via protocolo web podemos consumirlo tal como un servicio web. Desde Visual Studio 2010 creamos una aplicación de consola o Windows Forms y tenemos varias alternativas disponibles para generar un proxy que nos invoque los elementos que tenemos publicados por defecto en REST mediante el servicio listdata.svc. En esta demostración de tipo aplicación Windows Forms simplemente selecciono del menú principal la opción de Data en donde se muestra la opción de Visual Studio para agregar una conexión que apunte a diversos orígenes de datos.

Lo que vale la pena ver aquí es que ahora contamos con un nuevo conector hacia SharePoint.

A seleccionar Next simplemente se carga la ventana para hacer una referencia a un servicio WCF. Capturamos la URL de nuestro servicio listdata.svc de nuestro sitio SharePoint en cuestión y damos clic en el botón Go, para que Visual Studio descubra el contenido del servicio “el cual basado en REST obtendremos el contenido de nuestro sitio” y especificamos el namespace con el que estaremos haciendo referencia a nuestro proxy.

Damos clic en Ok y listo ya podemos generar instancias de nuestro proxy y realizar programáticamente invocaciones al contenido de nuestras listas. Cabe mencionar que al hacer la conexión vía Data Source de Visual Studio nos agrega una sección donde podemos arrastrar y soltar sobre nuestra lista de anuncios presentándonos las columnas y la posibilidad de mostrar los objetos sobre nuestro formulario, el proceso de vinculación lo realiza de forma automática y nos agrega el contexto de vinculación y el contexto de navegación dentro de un conjunto de datos.

Si tomamos nuestra lista de anuncios y la arrastramos y soltamos sobre nuestro formulario el resultado será un datagrid con su correspondiente objeto de navegación y contexto de vinculación.

Claro que nosotros podemos editar que columnas queremos incluir y atrapar eventos dentro del datagrid para determinar renglones nuevos o editados y programáticamente hacer algo al respecto.

Ya para terminar necesitamos realizar desde código la invocación a nuestra lista y pasarle como contexto de datos el resultado de nuestro servicio. Así mismo ocupamos también pasar el contexto de usuario para que podamos tener acceso seguro a SharePoint.

Lo que hay que hacer es:

Hacer referencia a nuestro namespace RESTDemo y a System.Net usando using
Instanciamos nuestro servicio generado por el proxy llamado “HomeDataContext” y pasamos como argumento dentro del constructor un objeto Uri apuntando a nuestro servicio listdata.svc.
A nuestro objeto instanciado necesitamos asignarle la credenciales de usuario con las que se autentificara en SharePoint para consumir los datos.
Asignamos a nuestro objeto de contexto de vinculación en su propiedad DataSource el resultado de nuestra lista.

using System.Net;
using WindowsFormsApplication9.RESTDemo;

namespace WindowsFormsApplication9
{
    public partial class Form1 : Form
    {

        private void Form1_Load(object sender, EventArgs e)
        {
            HomeDataContext dc = new HomeDataContext(new Uri("http://sp210-pdc/_vti_bin/listdata.svc"));
            dc.Credentials = CredentialCache.DefaultNetworkCredentials;
            announcementsBindingSource.DataSource = dc.Announcements;
        }
    }
}

El resultado:

Originalmente publicado en msmvps.com

Impersonation en una WebPart de SharePoint 2007 para insertar programaticamente en una lista personalizada

Haaron Gonzalez — Sat, 06 Oct 2007 01:43:00 GMT

No hace mucho tuve que desarrollar una WebPart para inserta programáticamente elementos sobre una lista personalizada de SharePoint. EL ambiente sobre el que estaba corriendo mi aplicación web era de un sitio SharePoint de publicación para internet con autentificación por formularios habilitada y acceso anónimo soportado. Cuando se ejecutaba mi código me mandaba a una página de denegación de acceso debido a credenciales no validas. Por supuesto que esto es un escenario donde se requiere “Impersonation”.

A continuación dejo una de las tantas opciones disponibles en código para lograr “Impersonation” en una WebPart de SharePoint 2007.

SPSecurity.RunWithElevatedPrivileges(delegate()
          {

              using (SPSite s = new SPSite(siteUrl))
              {
                
                  SPWeb w = s.OpenWeb();
                  w.AllowUnsafeUpdates = true;
                  w.Update();

                  SPList myList = w.Lists[listName];

                  SPListItem new = myList.Items.Add();
                  new["field1"] = txtField1.Text;
                  new["field2"] = txtField2.Text;
                  new["field3"] = this.Page.Request.Url.ToString();
                  new["field4"] = txtField3.Text.ToString();

                  new.Update();
              }


          });

Este fue el code del dia. Saludos