El blog de Lluis Franco : .NET

HowTo: Agrupando grupos :-)

lfranco — Thu, 26 Nov 2009 11:53:51 GMT

Una entrada rápida, no como la de ayer. Aunque el tema está bastante relacionado ya que ambos tratan de Active Directory e identidades.

Hoy vamos a ver una forma sencilla de obtener todos los grupos a los que pertenece un usuario, y agruparlos por su nombre de dominio. Y todo esto mediante una sola sentencia LINQ to objects. A ver quién es el guapo o guapa que me dice que LINQ to objects no es una maravilla!

El resultado que vamos a obtener es el siguiente (algunos nombres se han omitido por razones obvias :-P):

Groups under:
- Group name: Todos
- Group name: LOCAL
Groups under: BUILTIN
- Group name: Usuarios
- Group name: Administradores
Groups under: PRIMARY_DOMAIN_NAME
- Group name: xxx1
- Group name: xxx2
- Group name: xxx3
- Group name: xxx4
- Group name: xxxN
Groups under: NT AUTHORITY
- Group name: INTERACTIVE
- Group name: Usuarios autentificados

Y el código resultante es un método extensor para la clase WindowsIdentity, con dos funciones auxiliares en forma de métodos extensores de la clase NTAccount:

using System;

using System.Collections.Generic;

using System.DirectoryServices;

using System.DirectoryServices.ActiveDirectory;

using System.Linq;

using System.Net.NetworkInformation;

using System.Runtime.InteropServices;

using System.Security.Principal;

using System.Text;

namespace Alpha.Code

    public static class SecurityExtensions

        public static IOrderedEnumerable<IGrouping <string, NTAccount>>

            GetGroupsUnderDomains(this WindowsIdentity identity)

            var groups =

                        from grIdentity in identity.Groups

                        where grIdentity.IsValidTargetType(typeof(NTAccount))

                        select grIdentity.Translate(typeof(NTAccount)) as NTAccount into ntAccounts

                        let domainName = ntAccounts.GetDomainName()

                        let groupName = ntAccounts.GetAccountName()

                        orderby domainName

                        group ntAccounts by domainName into domainGroups

                        orderby domainGroups.Key

                        select domainGroups;

            return groups;

        public static string GetDomainName(this NTAccount account)

            string[] split = account.Value.Split('\\');

            return split.Length == 1 ? string.Empty : split[0];

        public static string GetAccountName(this NTAccount account)

            string[] split = account.Value.Split('\\');

            return split[split.Length - 1];

Para probarlo y ver el resultado:

var groups = WindowsIdentity.GetCurrent().GetGroupsUnderDomains();

foreach (var dg in groups)

    Console.WriteLine(string.Format("Groups under: {0}", dg.Key));

    foreach (var g in dg)

        Console.WriteLine(string.Format("  - Group name: {0}", g.GetAccountName()));

Un saludo desde las frías tierras de Andorra :-)

Noviembre 2009

** crossposting desde el blog de Lluís Franco en geeks.ms **

How To: ¿Como saber si el usuario actual es administrador del dominio?

lfranco — Wed, 25 Nov 2009 18:03:00 GMT

Nota: Es una pregunta que me encuentro de forma recurrente en los foros de desarrollo, así que lo apunto aquí para tener una referencia.

El escenario

Cuando desarrollamos una aplicación de escritorio, puede ser interesante saber a qué grupos pertenece el usuario que está ejecutando nuestra aplicación, para mostrar / ocultar / permitir / revocar ciertas acciones, u opciones. Por ejemplo, yo acostumbro a tener un botón en la barra de estado de mis aplicaciones que permite cambiar la cadena de conexión, y evidentemente, solo está visible cuando el usuario pertenece al grupo “Administradores del dominio”.

IsInRole

Para ello, el objeto WindowsPrincipal dispone de un método IsInRole, que nos dirà si un usuario pertenece a un grupo determinado. Genial, además este método tiene varias sobrecargas, de modo que podemos usarlo pasando el RID, SID, el nombre e incluso una constante basada en la enumeración WindowsBuiltIOnRole:

Nombre de miembro	Descripción
AccountOperator	Los operadores de cuentas administran las cuentas de los usuarios de un equipo o dominio.
Administrator	Los administradores tienen acceso completo y sin restricciones al equipo o dominio.
BackupOperator	Los operadores de copia de seguridad pueden reemplazar las restricciones de seguridad con el único propósito de hacer copias de seguridad de los archivos o de restaurarlas.
Guest	Los invitados tienen más restricciones que los usuarios.
PowerUser	Los usuarios avanzados poseen la mayoría de los permisos administrativos, con algunas restricciones. De este modo, los usuarios avanzados pueden ejecutar aplicaciones heredadas, además de aplicaciones certificadas.
PrintOperator	Los operadores de impresión pueden tomar el control de una impresora.
Replicator	Los replicadores permiten la duplicación de archivos en un dominio.
SystemOperator	Los operadores del sistema administran un equipo en particular.
User	Los usuarios no pueden realizar cambios accidentales o intencionados en todo el sistema. En consecuencia, pueden ejecutar aplicaciones certificadas, pero no la mayoría de las aplicaciones heredadas.

De modo que para saber si nuestro usuario es administrador local, basta con hacer esto:

WindowsPrincipal wp = new WindowsPrincipal(WindowsIdentity.GetCurrent());

return wp.IsInRole(WindowsBuiltInRole.Administrator);

Sencillo, verdad? A partir del usuario que ejecuta nuestra aplicación (válido también en caso de impersonación), creamos un objeto Principal e invocamos al método pasándole el grupo contra el que deseamos validar.

El problema de esta enumeración es que como su nombre indica, sólo contempla los grupos locales. Así que si queremos saber si pertenece a un grupo del dominio parece que tendremos que buscar el SID del grupo, o el nombre, y hardcodearlo ‘a mano’ en nuestra aplicación.

Feo verdad? Pues la verdad es que si, muy feo… vamos a investigar un poco más, a ver si encontramos otra forma.

Nota: Por motivos de rendimiento, para determinar la función del usuario se recomienda utilizar la sobrecarga de IsInRole(SecurityIdentifier) como sobrecarga preferible.

WellKnownSidType

Existe una enumeración llamada WellKnownSidType, que devuelve los identificadores de seguridad más utilizados, vamos a darle un vistazo:

Member name	Description
NullSid	Indicates a null SID.
WorldSid	Indicates a SID that matches everyone.
LocalSid	Indicates a local SID.
CreatorOwnerSid	Indicates a SID that matches the owner or creator of an object.
CreatorGroupSid	Indicates a SID that matches the creator group of an object.
CreatorOwnerServerSid	Indicates a creator owner server SID.
CreatorGroupServerSid	Indicates a creator group server SID.
NTAuthoritySid	Indicates a SID for the Windows NT authority.
DialupSid	Indicates a SID for a dial-up account.
NetworkSid	Indicates a SID for a network account. This SID is added to the process of a token when it logs on across a network.
BatchSid	Indicates a SID for a batch process. This SID is added to the process of a token when it logs on as a batch job.
InteractiveSid	Indicates a SID for an interactive account. This SID is added to the process of a token when it logs on interactively.
ServiceSid	Indicates a SID for a service. This SID is added to the process of a token when it logs on as a service.
AnonymousSid	Indicates a SID for the anonymous account.
ProxySid	Indicates a proxy SID.
EnterpriseControllersSid	Indicates a SID for an enterprise controller.
SelfSid	Indicates a SID for self.
AuthenticatedUserSid	Indicates a SID for an authenticated user.
RestrictedCodeSid	Indicates a SID for restricted code.
TerminalServerSid	Indicates a SID that matches a terminal server account.
RemoteLogonIdSid	Indicates a SID that matches remote logons.
LogonIdsSid	Indicates a SID that matches logon IDs.
LocalSystemSid	Indicates a SID that matches the local system.
LocalServiceSid	Indicates a SID that matches a local service.
NetworkServiceSid	Indicates a SID that matches a network service.
BuiltinDomainSid	Indicates a SID that matches the domain account.
BuiltinAdministratorsSid	Indicates a SID that matches the administrator account.
BuiltinUsersSid	Indicates a SID that matches built-in user accounts.
BuiltinGuestsSid	Indicates a SID that matches the guest account.
BuiltinPowerUsersSid	Indicates a SID that matches the power users group.
BuiltinAccountOperatorsSid	Indicates a SID that matches the account operators account.
BuiltinSystemOperatorsSid	Indicates a SID that matches the system operators group.
BuiltinPrintOperatorsSid	Indicates a SID that matches the print operators group.
BuiltinBackupOperatorsSid	Indicates a SID that matches the backup operators group.
BuiltinReplicatorSid	Indicates a SID that matches the replicator account.
BuiltinPreWindows2000CompatibleAccessSid	Indicates a SID that matches pre-Windows 2000 compatible accounts.
BuiltinRemoteDesktopUsersSid	Indicates a SID that matches remote desktop users.
BuiltinNetworkConfigurationOperatorsSid	Indicates a SID that matches the network operators group.
AccountAdministratorSid	Indicates a SID that matches the account administrators group.
AccountGuestSid	Indicates a SID that matches the account guest group.
AccountKrbtgtSid	Indicates a SID that matches the account Kerberos target group.
AccountDomainAdminsSid	Indicates a SID that matches the account domain administrator group.
AccountDomainUsersSid	Indicates a SID that matches the account domain users group.
AccountDomainGuestsSid	Indicates a SID that matches the account domain guests group.
AccountComputersSid	Indicates a SID that matches the account computer group.
AccountControllersSid	Indicates a SID that matches the account controller group.
AccountCertAdminsSid	Indicates a SID that matches the certificate administrators group.
AccountSchemaAdminsSid	Indicates a SID that matches the schema administrators group.
AccountEnterpriseAdminsSid	Indicates a SID that matches the enterprise administrators group.
AccountPolicyAdminsSid	Indicates a SID that matches the policy administrators group.
AccountRasAndIasServersSid	Indicates a SID that matches the RAS and IAS server account.
NtlmAuthenticationSid	Indicates a SID present when the Microsoft NTLM authentication package authenticated the client.
DigestAuthenticationSid	Indicates a SID present when the Microsoft Digest authentication package authenticated the client.
SChannelAuthenticationSid	Indicates a SID present when the Secure Channel (SSL/TLS) authentication package authenticated the client.
ThisOrganizationSid	Indicates a SID present when the user authenticated from within the forest or across a trust that does not have the selective authentication option enabled. If this SID is present, then OtherOrganizationSid cannot be present.
OtherOrganizationSid	Indicates a SID present when the user authenticated across a forest with the selective authentication option enabled. If this SID is present, then ThisOrganizationSid cannot be present.
BuiltinIncomingForestTrustBuildersSid	Indicates a SID that allows a user to create incoming forest trusts. It is added to the token of users who are a member of the Incoming Forest Trust Builders built-in group in the root domain of the forest.
BuiltinPerformanceMonitoringUsersSid	Indicates a SID that matches the group of users that have remote access to schedule logging of performance counters on this computer.
BuiltinPerformanceLoggingUsersSid	Indicates a SID that matches the group of users that have remote access to monitor the computer.
BuiltinAuthorizationAccessSid	Indicates a SID that matches the Windows Authorization Access group.
WinBuiltinTerminalServerLicenseServersSid	Indicates a SID is present in a server that can issue Terminal Server licenses.
MaxDefined	Indicates the maximum defined SID in the WellKnownSidType enumeration.

BINGO!!! Parece que tenemos el SID del grupo de admnistradores del dominio (lo he marcado en rojo en la tabla anterior).

Ahora vamos a generar el SID del grupo de adminstradores del dominio y ya podemos volver a probar el método IsInRole:

WindowsPrincipal wp = new WindowsPrincipal(WindowsIdentity.GetCurrent());

SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.AccountDomainAdminsSid, null);

return wp.IsInRole(sid);

Ops! Nuestro gozo en un pozo… se necesita informar el segundo argumento del constructor para el SID del grupo:

DomainSid

¿Y que kkgrnn$# representa que es este identificador? Pues según pone en la ayuda del constructor, debe proporcionarse el SID del dominio para que el constructor pueda devolver algunos identificadores de WellKnownSidType, entre los cuales está el de los administradores del dominio.

Dicho de otro modo, o sabemos el SID de nuestro dominio o todo lo anterior no vale para nada… :-(

¿Y cómo podemos saber el SID de dominio? Después de buscar un ratito, lo único que he encontrado es una utilidad de consola llamada PsGetSid, que forma parte de las PSTools del inefable Mark Russinovich. Basta descargar esta utilidad y ejecutarla desde la consola de este modo para saber el SID de nuestro dominio (el nombre de dominio en formato “microsoft.com” o “net.volvo.com”):

Sin embargo, me niego a tener que hacer esto para saber el identificador del dominio. Así que vamos a probar si podemos recuperar esta propiedad del esquema de AD mediante un DirectoryEntry. Para ello utilizaremos la clase Domain:

Domain d = Domain.GetDomain(new

    DirectoryContext(DirectoryContextType.Domain, getDomainName()));

using (DirectoryEntry de = d.GetDirectoryEntry())

    byte[] domSid = (byte[])de.Properties["objectSid"].Value;

    string sdomainSid = sIDtoString(domSid);

    Console.WriteLine(sdomainSid);

Nota: Aquí necesitaremos dos funciones de apoyo, la primera nos devuelve el nombre del domino, y la segunda transforma el array de bits del SID en su representación textual:

public static string getDomainName()

    return IPGlobalProperties.GetIPGlobalProperties().DomainName;

public static string sIDtoString(byte[] sidBinary)

    SecurityIdentifier sid = new SecurityIdentifier(sidBinary, 0);

    return sid.ToString();

A todo esto el valor de la variable sdomainSid es el esperado!!! :-D

Poniéndolo todo junto

Al igual que el alegre bandolero, también soy un fanático de los métodos extensores, así que vamos a encapsular todo esto en un método que extienda la clase WindowsIdentity. Aquí va todo el código junto:

using System.DirectoryServices;

using System.DirectoryServices.ActiveDirectory;

using System.Net.NetworkInformation;

using System.Security.Principal;

namespace Alpha.Code

    public static class SecurityExtensions

        public static bool IsDomainAdmin (this WindowsIdentity identity)

            Domain d = Domain.GetDomain(new

                DirectoryContext(DirectoryContextType.Domain, getDomainName()));

            using (DirectoryEntry de = d.GetDirectoryEntry())

                byte[] bdomSid = (byte[])de.Properties["objectSid"].Value;

                string sdomainSid = sIDtoString(bdomSid);

                WindowsPrincipal wp = new WindowsPrincipal(identity);

                SecurityIdentifier dsid = new SecurityIdentifier(sdomainSid);

                SecurityIdentifier dasid = new SecurityIdentifier(

                    WellKnownSidType.AccountDomainAdminsSid, dsid);

                return wp.IsInRole(dasid);

        public static string getDomainName()

            return IPGlobalProperties.GetIPGlobalProperties().DomainName;

        public static string sIDtoString(byte[] sidBinary)

            SecurityIdentifier sid = new SecurityIdentifier(sidBinary, 0);

            return sid.ToString();

Y la forma de usarlo es tan sencilla como esto:

if (WindowsIdentity.GetCurrent().IsDomainAdmin())

    //Acciones a realizar si el usuario es administrador de dominio...

Un saludo desde las frías tierras de Andorra :-)

Noviembre 2009

** crossposting desde el blog de Lluís Franco en geeks.ms **

VS2010: Aleluya! Mejoras en Project –> Refrences

lfranco — Thu, 29 Oct 2009 08:01:00 GMT

Leo en el blog de Scott, que por fin alguien me ha hecho caso :-)

Ya en las betas de la versión 2003 mandé una petición para que el cuadro de diálogo de referencias se cargara de forma asíncrona, y desde entonces no se puede decir que me hubiésen hecho demasiado caso. La verdad es que tampoco creo que me lo hayan hecho ahora, pero al menos alguien debe haber llegado a la misma conclusión: El cuadro de diálogo de agregar referencias tardaba horrores en cargar.

La verdad es que es normal, ya que en la versión 2008 todavía tenemos el mismo diálogo que en Visual Studio 6.0, ya ha llovido un poco.

Ahora, a partir de la beta 2 de 2010, este cuadro de diálogo se abre por defecto en la pestaña ‘Projects’ en lugar de mostrar las referencias de .NET, y esto es mucho más rápido.

Pero eso no es todo, ahora en las dos primeras pestañas, la carga de ensamblados se realiza ahora de forma asíncrona, de forma que no paraliza el IDE hasta que estan todos los ensamblados cargados en la lista.

Si, se que es una tonteria… pero a veces estos pequeños cambios hacen que uno sea bastante más productivo, o que al menos no se cabree con la herramienta cuando por error le das a esta ventana :-P

Artículo original:

http://weblogs.asp.net/scottgu/archive/2009/10/29/add-reference-dialog-improvements-vs-2010-and-net-4-0-series.aspx

Saludos a todos!

** crossposting desde el blog de Lluís Franco en geeks.ms **

El CodeCamp ha muerto… ¡viva el codeCamp!

lfranco — Tue, 20 Oct 2009 17:53:36 GMT

Que nadie se asuste... :-)

...que aquí no se ha muerto nadie. Simplemente se ha terminado el CodeCamp 2009 y ya estamos pensando en el próximo: Dónde se va a celebrar? Cuándo lo va a hacer? Qué cosas podemos mejorar? Y en fin, todas esas cuestiones habituales.

Y el evento... ah, el evento... ha salido estupendamente! Puedo decir sin temor a equivocarme que ha sido el mejor CodeCamp hasta ahora, e incluso me atrevería a decir que ha sido mejor evento montado jamás por la comunidad (al menos el mejor que he visto jamás): El número de inscritos ha sobrepasado todas las previsiones, ya que en las primeras reuniones se hablaba de 100 personas y al final se registraron más de 300. El cartel de ponentes ha sido de auténtico lujo, tanto por parte de MSDN como de MONO, y en ocasiones ha sido bastante complicado decidir a qué sesión asistir. Y cómo no, el ambiente y el networking ha sido una auténtica pasada. Daba gusto estar cenando o tomando una copa con alguno de los gurús, o con varios de los estudiantes que vinieron al TTT y se quedaron el resto del fin de semana.

Evidentemente también hay varias cosas a mejorar, como algunos aspectos técnicos, la wifi, o el audio en el Webcast con Lisa Feigenbaum. Sin embargo, lo importante es que aunque ha sido un curro tremendo, el resultado compensa de sobras, y cuando Vicenç nos ha empezando a mandar algunas de las primeras impresiones no he podido evitar leerlas con una sonrisa de satisfacción en los labios.

Desde aquí agradecer los esfuerzos de todos los que han contribuido a este fin de semana, en el que no todo ha sido el CodeCamp. Ya arrancábamos el viernes con otro eventazo, el TTT o Train The Trainers, que Microsoft ha tenido a bien hacerlo coincidir con el CodeCamp, para que muchos de los ponentes e incluso asistentes no nos tuviéramos que desplazar. Por otro lado, mis agradecimientos a los sponsors, a los ponentes, a la organización (pedazo de curro os habéis pegado!), al hotel, a los asistentes, etc.

GRACIAS A TODOS POR HABERLO HECHO POSIBLE!!!

Ahora, a pensar en el próximo CodeCamp... bueno, tal vez dejemos pasar un par de semanas :-P

Por cierto, este fin de semana he conocido a mucha gente, y a muchos de vosotros os prometí contactar por FaceBook. Os dejo aquí el enlace a mi perfil, por si queréis agregarme a vuestra lista de amigos (agradecería que pusiérais una nota “CodeCamp” para saber de dónde habéis salido :-P).

PD – A ver si mañana puedo publicar sobre las cenas: “La cara oscura del CodeCamp: Sexo, Cerveza y Rock & Roll” :-D

Andorra, Octubre 2009

** crossposting desde el blog de Lluís Franco en geeks.ms **

CodeCamp – Extra, extra, última hora (WebCast Lisa)

lfranco — Wed, 14 Oct 2009 14:21:00 GMT

Webcast online con Lisa Feigenbaum, Community Program Manager de VS - miércoles, 14 de octubre de 2009 a las 17:30.

Gracias al buen trabajo del colega Pep Lluís, el sábado por la tarde vamos a tener la suerte de poder contar en directo (vía WebCast online) con Lisa Feigenbaum (Community Program Manager for Visual Studio Managed Languages). Lisa nos guiará a través de las novedades que la nueva versión de Visual Basic nos va a traer.

Si vas a estar por allí no puedes perdértelo, y si no vas a estar... ¿a qué demonios estás esperando? :-)

Por cierto, en el nuevo blog de Lisa hoy aparece Pep, en una foto de la entrevista para DotNetMania que le hicieron él y Octavio a Lisa el pasado verano.

No os podéis imaginar que ganas tengo de que llegue el CodeCamp! :-D

Saludos @Andorra

** crossposting desde el blog de Lluís Franco en geeks.ms **

MVP por séptimo año consecutivo! :-D

lfranco — Thu, 01 Oct 2009 15:02:00 GMT

Oh! Que detalle más bonito!

Han querido hacerlo coincidir con el lanzamiento oficial de Windows 7 (supongo que adivináis porque se llama 7, no? :-P).

Bromas aparte y como cada año que pasa, recibir esta notificación me produce una tremenda alegría, no sólo por el reconocimiento que significa (y que no estoy muy seguro de merecer), sino porque me permite estar en contacto con un grupo de una tremenda calidad, tanto técnica como humana. Esto es sin duda alguna lo mejor del programa MVP.

El programa MVP… casi nada. Cada año Microsoft reconoce a un grupo de expertos independientes que han colaborado con la comunidad a nivel mundial. Ya sea contestando las preguntas de otros usuarios en los foros públicos, posteando artículos en webs o blogs, organizando reuniones de grupos de usuarios o participando como ponente en diferentes sesiones. No es de extrañar que cuando nos reunimos mire a mi alrededor y piense “jo, qué nivel! La de gente realmente buena que hay... no sé exactamente que pinto yo aquí!”.

Todavía recuerdo mi primera incursión en el programa MVP. Fue en 2003, y estaba en Madrid a raíz de mi primera nominación como MVP y de un viaje por trabajo al SIMO. Yo llegué un miércoles y el viernes teníamos un Open Day en las instalaciones de Microsoft. Iba a ser mi primera visita a la compañía, y la verdad es que no tenía ni idea de cómo iba a resultar... ni qué tipo de gente me iba a encontrar :-)

Después de visitar durante un par de días un montón de stands y de mantener algunas reuniones con proveedores en el SIMO, llegó el viernes y bajé a desayunar al hotel, para después dirigirme al autocar que debía llevarnos a las antiguas instalaciones de Microsoft. En aquellos momentos lo único que sabía era que iba a conocer a un montón de gente interesante, otros MVPs, empleados de MS, que obtendría información ‘privilegiada’ de futuros productos y tendencias, y que por la noche tendríamos una cena, lo cual ya bastaba de sobras para justificar el viaje.

Como no conocía a nadie, ni sabía de qué iba el tema salí con el mismo uniforme que los dos días anteriores, es decir, con traje y corbata (sip, soy de esos tíos a los que deben ir a trabajar de esta guisa, y al final te acostumbras :-P). Pues no os podéis imaginar el cachondeito que hubo en el autocar! De hecho, con los años mi prima Evas, ex-MVP, llego a contarme que otros MVPs se pensaron que yo era algún cargo de Microsoft que aprovechaba el viaje, jejeje... Nada más lejos, y nada más iniciar el viaje y empezar a charlar ya me di cuenta (demasiado tarde) de mi error, pero ya estaba hecho, así que tuve que apechugar todo el día con la corbata como un campeón.

Aquel mismo día conocí a muchos compañeros MVP que a día de hoy son muy buenos amigos, y a algunos de ellos que ya no lo son, pero continúan siendo muy buenos amigos. Si un día tengo tiempo y me siento inspirado os contaré algunas aventuras que hemos compartido a lo largo de los años...

Un abrazo enorme a todos, los que son, los que no, y en general a todos aquellos que dedican su tiempo a hacer más grande la comunidad. Todos son MVP, tengan o no tengan la distinción. Entre todos estamos contribuyendo a hacer algo grande.

Nos vemos en las comunidades, eventos, charlas de grupos, etc.

Lluís Franco

Octubre 2009

PD – Acabo de encontrarme con unas viejas fotos de pasados MVP Open Days, las colgaré en FaceBook en breve :-D

** crossposting desde el blog de Lluís Franco en geeks.ms **

El CodeCamp 2009 se acerca…

lfranco — Mon, 21 Sep 2009 12:36:00 GMT

Hola a todos,

Ya queda menos de un mes para uno de los eventos más esperados de este año: el CodeCamp 2009. Este evento ha sido organizado por varios grupos de usuarios de España y del extranjero (Andorra también existe!), y se realizará en Salou (Tarragona), durante el fin de semana del 17 y 18 de Octubre.

El CodeCamp Tarragona 2009 es un evento gratuito organizado por y para la comunidad de .NET, cuyo objetivo es reunir a profesionales, usuarios y entusiastas interesados en la plataforma .NET y Mono para intercambiar experiencias y asistir a un conjunto de ponencias realizadas por especialistas de reconocido prestigio.

El Code Camp estará compuesto por una serie de sesiones divididas en varios tracks. Las sesiones abarcarán presentaciones, charlas informales y sesiones prácticas. Estáis todos invitados a asistir, hablar y participar.

Tendremos una mezcla de ponentes, desde MVPs, directores, autores y, los más importante, desarrolladores como tú, ya que nos interesa tratar temas y problemas reales a los que los profesionales se enfrentan en el trabajo diario.

En esta ocasión, voy a participar como ponente en uno de los tracks, conjuntamente con mis buenos amigos Jorge Serrano y Pep Lluís Bano. De modo que si te quieres divertir y estar al loro de las últimas novedades de VB2010 pásate por allí y hablamos un rato.

Más información en:

http://www.codecamp.es/

PD – El día anterior celebraremos el TTT (Train the trainers), de modo que si vas a ir nos vemos allí :-)

** crossposting desde el blog de Lluís Franco en geeks.ms **

Haciendo prototipos con SketchFlow

lfranco — Mon, 27 Apr 2009 09:07:02 GMT

Según leo esta mañana en el blog de Somasegar, existe un nuevo conjunto de herramientas muy chulo para Expression Blend 3 llamado SketchFlow, pensado para la realización de prototipos en las primeras etapas del diseño de software.

Con SketchFlow podemos:

a) Esbozar las ideas
b) Convertir esas ideas en prototipos de trabajo.
c) Presentar y compartir estas experiencias de usuario interactivo mediante el SketchFlow player.

Darle un vistazo al artículo original que vale la pena:

http://blogs.msdn.com/somasegar/archive/2009/04/25/prototyping-with-sketchflow.aspx

** crossposting desde el blog de Lluís Franco en geeks.ms **

Google Chrome usa ClickOnce :-)

lfranco — Mon, 06 Apr 2009 11:02:00 GMT

Pues eso. Tal vez muchos de vosotros ya lo sabíais pero esta mañana me he quedado de piedra al comprobar que la instalación de Google Chrome se realiza mediante la tecnología ClickOnce de Microsoft. Curioso verdad? Para muestra un botón:

Si lo piensas es normal, ya que el código del producto para Windows no deja de ser una solución de Visual Studio 2005 (15 proyectos si no recuerdo mal), de modo que es relativamente normal que se hayan aprovechado de una tecnología tan *cojonuda* (y perdón por la expresión) com es ClickOnce para el despliegue de aplicaciones.

Lo que no deja de ser gracioso es que de momento Chrome no tenga versiones estables para Mac ni para Linux (de hecho según los mismos desarrolladores "Esta mas cerca del comienzo que del fin"), y la única versión que funciona más o menos bien esté desarrollada con la herramienta de desarrollo más popular de la competencia :-P

En fin, como dije antes… curioso, verdad?

** crossposting desde el blog de Lluís Franco en geeks.ms **

ClickOnce, actualizar una aplicación ‘on demand’

lfranco — Thu, 02 Apr 2009 15:47:00 GMT

Una de las grandes características disponibles a partir de VS2005 fue la tecnología ClickOnce, que permitía distribuir aplicaciones de forma asombrosamente sencilla. Hoy no nos vamos a dedicar a explicar con detalle esta tecnología (supongo que muchos de vosotros ya la estaréis utilizando), si no que nos vamos a centrar en extender su funcionalidad para comprobar por código si existen nuevas versiones publicadas, y en caso afirmativo actualizar la misma.

La verdad es que utilizar la API de ClickOnce está tirado, y nos permite hacer cosas tan chulas como esta:

El código para comprobar si existen actualizaciones es el siguiente:

private static void InstallUpdateSyncWithInfo()

    UpdateCheckInfo info = null;

    if (ApplicationDeployment.IsNetworkDeployed)

        ApplicationDeployment ad = ApplicationDeployment.CurrentDeployment;

try

            info = ad.CheckForDetailedUpdate();

        catch (DeploymentDownloadException dde)

            MessageBox.Show(String.Format(

                Properties.Settings.Default.CLICKONCE_CANT_DOWNLOAD_UPDATE,

                dde.Message, MessageBoxButtons.OK,

                MessageBoxIcon.Exclamation));

            return;

        catch (InvalidDeploymentException ide)

            MessageBox.Show(String.Format(

                Properties.Settings.Default.CLICKONCE_CORRUPT_DEPLOYMENT,

                ide.Message, MessageBoxButtons.OK,

                MessageBoxIcon.Exclamation));

            return;

        catch (InvalidOperationException ioe)

            MessageBox.Show(String.Format(

                Properties.Settings.Default.CLICKONCE_NO_CLICKONCE_DEPLOYMENT,

                ioe.Message, MessageBoxButtons.OK,

                MessageBoxIcon.Exclamation));

            return;

        if (info.UpdateAvailable)

            Boolean doUpdate = true;

            if (!info.IsUpdateRequired)

                DialogResult dr = MessageBox.Show(

                    string.Format(Properties.Settings.Default.CLICKONCE_UPDATE_AVAILABLE,

                    info.AvailableVersion.ToString()),

                    Application.ProductName, MessageBoxButtons.OKCancel,

                    MessageBoxIcon.Information);

                if (!(DialogResult.OK == dr))

                    doUpdate = false;

            else

                MessageBox.Show(

                    String.Format(Properties.Settings.Default.CLICKONCE_MANDATORY_UPDATE,

                    info.MinimumRequiredVersion.ToString(),

                    ApplicationDeployment.CurrentDeployment.CurrentVersion.ToString()),

                    Application.ProductName, MessageBoxButtons.OK,

                    MessageBoxIcon.Information);

            if (doUpdate)

try

                    ad.Update();

                    MessageBox.Show(Properties.Settings.Default.CLICKONCE_UPDATE_SUCCESSFULLY,

                        Application.ProductName, MessageBoxButtons.OK,

                        MessageBoxIcon.Information);

                    Application.Restart();

                catch (DeploymentDownloadException dde)

                    MessageBox.Show(String.Format(

                        Properties.Settings.Default.CLICKONCE_CANT_INSTALL_UPDATE,

                        dde.Message, MessageBoxButtons.OK,

                        MessageBoxIcon.Exclamation));

                    return;

        else

            MessageBox.Show(Properties.Settings.Default.CLICKONCE_NO_UPDATES_AVAILABLES,

                Application.ProductName, MessageBoxButtons.OK,

                MessageBoxIcon.Information);

Basta acompañar este código con unas constantes definidas en los settings de nuestra aplicación y voilá!

A continuación os muestro un ejemplo del fichero de settings por si alguno se lo quiere personalizar:

<?xml version='1.0' encoding='utf-8'?>

<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings"

  CurrentProfile="(Default)" GeneratedClassNamespace="TestClickOnceDeployment.Properties" GeneratedClassName="Settings">

  <Profiles />

  <Settings>

    <Setting Name="CLICKONCE_CANT_DOWNLOAD_UPDATE" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      La nueva versión de la aplicación no puede ser descargada en estos momentos.\n\

      Por favor, revise la connexión de red o pruébelo un poco más tarde. Error: {0}</Value>

    </Setting>

    <Setting Name="CLICKONCE_CORRUPT_DEPLOYMENT" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      No se puede verificar la nueva versión de la aplicación. La publicación ClickOnce está corrupta.

      Por favor, redistribuya de nuevo la aplicación i pruébelo un poco más tarde. Error: {0}</Value>

    </Setting>

    <Setting Name="CLICKONCE_NO_CLICKONCE_DEPLOYMENT" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      La aplicación no se puede actualizar. Parece ser que la publicación no es una aplicación ClickOnce válida. Error: {0}</Value>

    </Setting>

    <Setting Name="CLICKONCE_UPDATE_AVAILABLE" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      Se ha encontrado disponible una actualización. Desea actualitzar la aplicación a la versión '{0}'?</Value>

    </Setting>

    <Setting Name="CLICKONCE_MANDATORY_UPDATE" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      Esta aplicación ha detectado que la versión mínima de l'aplicació es la versión '{0}',

      i actualmente se está utilizando la versión '{1}'.

      A continuación la aplicación se actualitzará y reiniciará.</Value>

    </Setting>

    <Setting Name="CLICKONCE_UPDATE_SUCCESSFULLY" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      La aplicación se ha actualitzado correctamente, y a continuación se reiniciará.</Value>

    </Setting>

    <Setting Name="CLICKONCE_CANT_INSTALL_UPDATE" Type="System.String" Scope="Application">

      <Value Profile="(Default)">

      La nueva versión de la aplicación no se puede instalar en estos momentos.\n\n

      Por favor, revise la connexión de red o pruébelo un poco más tarde. Error: {0}</Value>

    </Setting>

    <Setting Name="CLICKONCE_NO_UPDATES_AVAILABLES" Type="System.String" Scope="Application">

      <Value Profile="(Default)">No se han encontrado actualitzacions disponibles de la aplicación.</Value>

    </Setting>

  </Settings>

</SettingsFile>

Y eso es todo… Un saludo desde Andorra!

** crossposting desde el blog de Lluís Franco en geeks.ms **

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (VII)

lfranco — Fri, 20 Mar 2009 08:07:00 GMT

Entradas anteriores de la serie:

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (I)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (II)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (III)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (IV)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (V)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (VI)

Han pasado unos días desde que publiqué la última entrada, y es que voy absolutamente desbordado de curro.

Pero como lo prometido es deuda, vamos a proseguir con el tema, ya quedan un par de temas por ver antes de concluir la serie:

Cómo ejecutar distintos threads y mostrar el progreso (Callbacks).

Cómo distribuir nuestro complemento, creando un archivo MSI (Windows Installer packages).

Además, os dije que en el último post publicaría el código fuente del proyecto… y varios de vosotros ya lo habéis reclamado con insistencia :-P

De modo que vamos a hacerlo al revés: Hoy publico el código fuente del proyecto, y mañana (espero) continuaré el resto de la serie. De este modo al menos ya tendreis el código para jugar con él, y poder machacarme a preguntas…

El proyecto incluye el código de ejemplo del Add-In y el proyecto de instalación, y lo podéis descargar desde este enlace de Skydrive:

http://cid-f3a970280830b5fe.skydrive.live.com/self.aspx/MSDN%20Samples/OutlookToMOSS/OutlookToMOSS.zip

Saludos desde Andorra,

** crossposting desde el blog de Lluís Franco en geeks.ms **

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (VI)

lfranco — Thu, 05 Mar 2009 14:57:00 GMT

Entradas anteriores de la serie:

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (I)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (II)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (III)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (IV)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (V)

Ahora que parece que Bender está un poco más sobrio que de costumbre, prosigamos con la serie... que sabéis como se pone cuando no bebe.

Menú del día:

De primero: Cómo guardar un fichero en una biblioteca de documentos de SharePoint manteniendo el control de versiones.

De segundo: Cómo modificar los metadatos del fichero una vez subido a la biblioteca (From, To, Subject).

Postre: Pastel especial de la casa.

Pan, Vino y Café incluidos

El primero:

Es curioso, pero SharePoint en la versión actual no implementa “de serie” ningún mecanismo para subir documentos a una librería de documentos. Ahora que nos hemos quedado con la boca abierta, vamos a explicar algunos mecanismos para hacerlo por nuestra cuenta.

El bueno de mi tío Rodrigo hace un tiempo que publicó un post al respecto, en el cual se mostraba cómo subir ficheros a un SharePoint. Pero como él mismo decía, la pega estaba en que usando esta técnica no se disponía de historial de versiones. La alternativa era crearse un WebService propio, tal y como se explica en este artículo, aunque es una solución que no siempre se puede usar. Hoy veremos una tercera alternativa que permite hacerlo sin tener que recurrir a la creación de un WebService. La he probado en un servidor MOSS y en un par de WSS, uno local y el otro hospedado en un hosting en USA. Y en ambos funciona perfectamente, aunque en el segundo los tiempos se demoran un poco...

Describamos los elementos que necesitamos a continuación:

Para empezar vamos a crear una clase FileInfo para encapsular lo relativo al fichero que vamos a subir (nombre, propiedades, URI, y por supuesto los bytes):

public class FileInfo

    public string m_URL;

    public byte[] m_bytes;

    public Dictionary<string, object> m_properties;

    public ListInfo m_listInfo;

    public bool m_ensureFolders = true;

    private Uri m_uri;

    public bool HasProperties

get

            return m_properties != null && m_properties.Count > 0;

    public string RelativeFilePath

get

            return m_URL.Substring(m_URL.IndexOf(m_listInfo.m_rootFolder) + 1);

    public Uri URI

get

            if (m_uri == null) m_uri = new Uri(m_URL);

            return m_uri;

    public string LookupName

get

            if (m_listInfo != null && !string.IsNullOrEmpty(m_listInfo.m_listName))

                return m_listInfo.m_listName;

            return URI.LocalPath;

    public FileInfo(string url, byte[] bytes, Dictionary<string, object> properties)

        m_URL = url.Replace("%20", " ");

        m_bytes = bytes;

        m_properties = properties;

A continuación un método Upload con dos sobrecargas, que será el que invocaremos desde la ventana encargada de mostrar el progreso de la operación. Éste será el encargado de recibir la URL de destino, los bytes del fichero a subir (previamente debemos guardar el elemento de correo en un fichero o stream), las propiedades, y el elemento de correo para poder actualizar las columnas de metadatos. Este método Upload será el encargado de a su vez llamar al método TryToUpload, que realmente será el encargado de subir el fichero:

public bool Upload(string destinationUrl, byte[] bytes, Dictionary<string, object> properties, Outlook.MailItem item)

    return Upload(new FileInfo(destinationUrl, bytes, properties), item);

public bool Upload(FileInfo fileInfo, Outlook.MailItem item)

    if (fileInfo.HasProperties)

        fileInfo.m_listInfo = m_lists.Find(fileInfo);

    bool result = TryToUpload(fileInfo, item);

    if (!result && fileInfo.m_ensureFolders)

        string root = fileInfo.URI.AbsoluteUri.Replace(fileInfo.URI.AbsolutePath, "");

        for (int i = 0; i < fileInfo.URI.Segments.Length - 1; i++)

            root += fileInfo.URI.Segments;

            if (i > 1) CreateFolder(root);

        result = TryToUpload(fileInfo, item);

    return result;

Y para terminar, el método TryToUpload que se encarga de crear el objeto WebRequest necesario, crear el stream y actualizar los valores de las propiedades de los campos, para invocar finalmente el método UpdateListItems del servicio Web:

private bool TryToUpload(FileInfo fileInfo, Outlook.MailItem item)

try

        WebRequest request = WebRequest.Create(fileInfo.m_URL);

        request.Credentials = sharePointLists.Credentials;

        request.Method = "PUT";

        byte[] buffer = new byte[1024];

        using (Stream stream = request.GetRequestStream())

        using (MemoryStream ms = new MemoryStream(fileInfo.m_bytes))

            for (int i = ms.Read(buffer, 0, buffer.Length); i > 0; i = ms.Read(buffer, 0, buffer.Length))

                stream.Write(buffer, 0, i);

        WebResponse response = request.GetResponse();

        response.Close();

        if (fileInfo.HasProperties)

            StringBuilder sb = new StringBuilder();

            sb.Append("<Method ID='1' Cmd='Update'><Field Name='ID'/>");

            sb.AppendFormat("<Field Name='FileRef'>{0}</Field>", fileInfo.m_URL);

            foreach (KeyValuePair<string, object> property in fileInfo.m_properties)

                sb.AppendFormat("<Field Name='{0}'>{1}</Field>", property.Key, property.Value);

            updateMetadataColumns(fileInfo, item, sb);

            sb.Append("</Method>");

            System.Xml.XmlElement updates = (new System.Xml.XmlDocument()).CreateElement("Batch");

            updates.SetAttribute("OnError", "Continue");

            updates.SetAttribute("ListVersion", fileInfo.m_listInfo.m_version);

            updates.SetAttribute("PreCalc", "TRUE");

            updates.InnerXml = sb.ToString();

            sharePointLists.Url = fileInfo.m_listInfo.m_webUrl + "/_vti_bin/Lists.asmx";

            XmlNode updatesResponse = sharePointLists.UpdateListItems(fileInfo.m_listInfo.m_listName, updates);

            if (updatesResponse.FirstChild.FirstChild.InnerText != "0x00000000")

                throw new Exception("Could not update properties.");

        return true;

    catch (WebException ex)

        throw ex;

Lo juntamos todo, compilamos, probamos a subir algunos mensajes varias veces y voilá! Si observamos el control de versiones veremos lo siguiente:

El segundo:

Si hemos observado con atención el código del método TryToUpload seguramente hemos visto una llamada a un método updateMetaDataColumns, al cual se le pasa el StringBuilder que estamos construyendo, para que nos agregue los valores de los metadatos (cuya sintaxis que expresarse en XML según la ayuda del método UpdateListItems). El código es muy sencillo y básicamente lo que hace es comprobar si en la lista destino existen las columnas de metadatos, y en caso afirmativo modificar su valor:

private void updateMetadataColumns(FileInfo fileInfo, Outlook.MailItem item, StringBuilder sb)

    var cols = from c in SharePointExtensions.getListColumns(

               sharePointLists, fileInfo.m_listInfo.m_listName)

               where c.Hidden == false && c.Sealed == false && c.ReadOnly == false

               select c;

    Dictionary<string, SPColumnInfo> columns = cols.ToDictionary(c => c.Name);

    if (columns.ContainsKey(Properties.Settings.Default.COL_SUBJECT) && item != null)

        sb.AppendFormat("<Field Name='{0}'>{1}</Field>",

            Properties.Settings.Default.COL_SUBJECT, item.Subject);

    if (columns.ContainsKey(Properties.Settings.Default.COL_FROM) && item != null)

        sb.AppendFormat("<Field Name='{0}'>{1}</Field>",

            Properties.Settings.Default.COL_FROM, item.SenderName);

    if (columns.ContainsKey(Properties.Settings.Default.COL_TO) && item != null)

        sb.AppendFormat("<Field Name='{0}'>{1}</Field>",

            Properties.Settings.Default.COL_TO, item.To);

    if (columns.ContainsKey(Properties.Settings.Default.COL_CC) && item != null)

        sb.AppendFormat("<Field Name='{0}'>{1}</Field>",

            Properties.Settings.Default.COL_CC, item.CC);

    if (columns.ContainsKey(Properties.Settings.Default.COL_BCC) && item != null)

        sb.AppendFormat("<Field Name='{0}'>{1}</Field>",

            Properties.Settings.Default.COL_BCC, item.BCC);

    if (columns.ContainsKey(Properties.Settings.Default.COL_SIZE) && item != null)

        sb.AppendFormat("<Field Name='{0}'>{1}</Field>",

            Properties.Settings.Default.COL_SIZE, item.Size);

    if (columns.ContainsKey(Properties.Settings.Default.COL_SENT) && item != null)

        string dt = item.SentOn.ToString("yyyy-MM-ddTHH:mm:ssZ");

        sb.AppendFormat("<Field Name='{0}'>{1}</Field>",

            Properties.Settings.Default.COL_SENT, dt);

    if (columns.ContainsKey(Properties.Settings.Default.COL_IMPORTANCE) && item != null)

        string im = string.Empty;

        switch (item.Importance)

            case Microsoft.Office.Interop.Outlook.OlImportance.olImportanceHigh:

                im = Properties.Settings.Default.COL_IMPORTANCE_HIGH;

                break;

            case Microsoft.Office.Interop.Outlook.OlImportance.olImportanceLow:

                im = Properties.Settings.Default.COL_IMPORTANCE_LOW;

                break;

            case Microsoft.Office.Interop.Outlook.OlImportance.olImportanceNormal:

            default:

                im = Properties.Settings.Default.COL_IMPORTANCE_MEDIUM;

                break;

        sb.AppendFormat("<Field Name='{0}'>{1}</Field>",

            Properties.Settings.Default.COL_IMPORTANCE, im);

El postre:

Ingredientes :
125 gr. de chocolate
60 gr. de mantequilla
125 gr. de azúcar
3 huevos
60 gr. de maizena

Receta :
Fundir el chocolate con la mantequilla a fuego lento.
Separar las yemas y las claras.
Mezclar el azúcar con las yemas de los huevos.
Añadir la maicena y después el chocolate fundido.
Montar las claras de huevo a punto de nieve y añadirlas lentamente a la mezcla.
Verter la mezcla en un molde donde se ha extendido la mantequilla previamente.
Hornearlo entre 20 ó 25 minutos a 180º.

Para terminar:

En los próximos artículos veremos cómo realizar este proceso de subida de ficheros de forma asíncrona usando callbacks, para poder continuar trabajando con Outlook y mostrar el progreso en una barra. También para cerrar la serie, veremos los pasos que hay que hacer para construir el proyecto de instalación de nuestro Add-In, y así poder distribuirlo.

Nos vemos!

** crossposting desde el blog de Lluís Franco en geeks.ms **

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (V)

lfranco — Tue, 03 Mar 2009 17:28:00 GMT

Entradas anteriores de la serie:

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (I)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (II)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (III)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (IV)

Después de algunos días sin poder seguir con la serie porque han detenido a Bender hay que sacar adelante otros proyectos, volvemos a la carga con lo que promete ser la serie de artículos más larga que he publicado hasta ahora en este blog.

Antes de nada vamos a ponernos al día:

Que pretendemos?

Crear un add-in de Outlook que permita guardar nuestros correos en una librería de documentos de SharePoint (tanto MOSS como WSS).

Que necesitamos?

Cómo crear un complemento para Office (VSTO). visto
Cómo registrar acciones en los menús de la aplicación host (Outlook). visto
Cómo conectar con un servidor MOSS/WSS con diferentes credenciales de usuario (System.Net.NetworkCredential) visto
Cómo acceder a los sitios y listas de un site de MOSS/WSS (servicios Web de SharePoint). visto
Cómo interpretar la información XML devuelta por los servicios (LINQ to XML). visto
Cómo extender el modelo de objetos de SharePoint para acceder los valores devueltos por los servicios Web.
Cómo crear las columnas necesarias en una lista para guardar los metadatos del elementos de correo (From, To, Subject).
Cómo guardar un fichero en una biblioteca de documentos de SharePoint con control de versiones (DocLibHelper).
Cómo ejecutar distintos threads y mostrar el progreso (Callbacks).
Cómo distribuir nuestro complemento, creando un archivo MSI (Windows Installer packages).

Que vamos a ver hoy?

En este post vamos a centrarnos en cómo obtener datos de los servicios Web de SharePoint. En nuestro caso necesitamos obtener las colecciones de sitios, las librerías de cada uno de los sitios, y las carpetas de cada librería para mostrarlos en una ventana que permita al usuario seleccionar la ubicación en la que desea guardar los elementos de coreo:

Del mismo modo, vamos a necesitar obtener las columnas de la librería seleccionada, para comprobar si ya existen las columnas para almacenar los metadatos de los elementos de correo, y en caso contrario proceder a crearlas (esto va a ir muy bien para posteriormente poder clasificar los elementos).

Extendiendo el modelo de objetos de SharePoint

En el post anterior ya vimos que habíamos declarado algunas clases de apoyo (como la clase ‘SPSiteInfo’) para que nuestros métodos (como el método ‘getSiteSubSites’ que también vimos en el anterior post) pudiesen devolver colecciones genéricas de éestos tipos de datos, lo cual es mucho más manejable que pelearnos con el XML que devuelven los servicios Web de SharePoint.

Los métodos que vamos a crear son:

getSiteSubSites: Devuelve una lista genérica de objetos ‘SPSiteInfo’, a partir de un servicio Web websProxy.Webs
getSiteLists: Devuelve una lista genérica de objetos ‘SPListInfo’, a partir de un servicio Web listsProxy.Lists
getListFolders: Devuelve una lista genérica de objetos ‘SPFolderInfo’, a partir de un servicio Web listsProxy.Lists
getListColumns: Devuelve una lista genérica de objetos ‘SPFolderInfo’, a partir de un servicio Web listsProxy.Lists y de un listID (GUID)
createMetadataColumns: Crea las columnas de metadatos definidas en los settings del add-in en una lista, a partir de un servicio Web listsProxy.Lists y de un listID (GUID).

Las clases de apoyo son:

public class SPSiteInfo

    public string Title { get; set; }

    public string URL { get; set; }

    public SPSiteInfo()

//

    public SPSiteInfo(string title, string url)

        Title = title;

        URL = url;

public class SPListInfo

    public Guid ID { get; set; }

    public string Title { get; set; }

    public string URL { get; set; }

    public SPListInfo()

//

    public SPListInfo(Guid id, string title, string url)

        ID = id;

        Title = title;

        URL = url;

public class SPFolderInfo

    public string Title { get; set; }

    public string URL { get; set; }

    public SPFolderInfo()

//

    public SPFolderInfo(string title, string url)

        Title = title;

        URL = url;

public class SPColumnInfo

    public string ID { get; set; }

    public string Type { get; set; }

    public string DisplayName { get; set; }

    public string Name { get; set; }

    public bool Hidden { get; set; }

    public bool Sealed { get; set; }

    public bool ReadOnly { get; set; }

    public SPColumnInfo()

//

    public SPColumnInfo(string id, string type,

        string displayName, string name, bool hidden,

        bool issealed, bool isreadonly)

        ID = id;

        Type = type;

        DisplayName = displayName;

        Name = name;

        Hidden = hidden;

        Sealed = issealed;

        ReadOnly = isreadonly;

Y el código de los métodos será el siguiente:

public class SharePointExtensions

    public static List<SPSiteInfo> getSiteSubSites(websProxy.Webs sharePointWebs)

try

            XmlNode websResult = sharePointWebs.GetWebCollection();

            XDocument results = XDocument.Parse(websResult.OuterXml);

            XName name = XName.Get("Web", "http://schemas.microsoft.com/sharepoint/soap/");

            var webs = from item in results.Descendants(name)

                       select new SPSiteInfo

                           item.Attribute("Title").Value,

                           item.Attribute("Url").Value

);

            return webs.ToList();

        catch (Exception ex)

            throw ex;

    public static List<SPListInfo> getSiteLists(listsProxy.Lists sharePointLists)

try

            XmlNode listsResult = sharePointLists.GetListCollection();

            XDocument results = XDocument.Parse(listsResult.OuterXml);

            XName name = XName.Get("List", "http://schemas.microsoft.com/sharepoint/soap/");

            var lists = from item in results.Descendants(name)

                        where item.Attribute("ServerTemplate").Value.ToString() ==

                            Properties.Settings.Default.SERVER_TEMPLATE

                        select new SPListInfo

                            new Guid(item.Attribute("ID").Value),

                            item.Attribute("Title").Value,

                            item.Attribute("DefaultViewUrl").Value

);

            return lists.ToList();

        catch (Exception ex)

            throw ex;

    public static List<SPFolderInfo> getListFolders(listsProxy.Lists sharePointLists,

        string listName, string listText, string folderURL)

try

            XmlDocument xmlDoc = new System.Xml.XmlDocument();

            XmlNode ndQuery = xmlDoc.CreateNode(XmlNodeType.Element, "Query", "");

            XmlNode ndViewFields =

              xmlDoc.CreateNode(XmlNodeType.Element, "ViewFields", "");

            XmlNode ndQueryOptions = null;

            if (listName != folderURL)

                ndQueryOptions = xmlDoc.CreateNode(

                    XmlNodeType.Element, "QueryOptions", "");

                ndQueryOptions.InnerXml = string.Format(

                    "<Folder>{0}/{1}</Folder>", listName, folderURL);

            XName name = XName.Get("data", "urn:schemas-microsoft-com:rowset");

            XmlNode ndListItems =

                    sharePointLists.GetListItems(listText, null, ndQuery,

                    ndViewFields, null, ndQueryOptions, null);

            XDocument results = XDocument.Parse(ndListItems.OuterXml);

            var folders = from item in results.Descendants(name).Elements()

                          where item.Attribute("ows_ContentType").Value == "Carpeta"

                          select new SPFolderInfo

                             item.Attribute("ows_BaseName").Value,

                             item.Attribute("ows_ServerUrl").Value

);

            return folders.ToList();

        catch (Exception ex)

            throw ex;

    public static List<SPColumnInfo> getListColumns(listsProxy.Lists sharePointLists, string siteID)

try

            List<SPColumnInfo> columns =new List<SPColumnInfo>();

            XmlNode listsResult = sharePointLists.GetList(siteID);

            XDocument results = XDocument.Parse(listsResult.OuterXml);

            XName name = XName.Get("Field", "http://schemas.microsoft.com/sharepoint/soap/");

            var lists = from item in results.Descendants(name)

                        select item;

            foreach (var item in lists.ToList())

                XAttribute aID = item.Attribute("ID");

                XAttribute aType = item.Attribute("Type");

                XAttribute aDisplayName = item.Attribute("DisplayName");

                XAttribute aName = item.Attribute("Name");

                XAttribute aHidden = item.Attribute("Hidden");

                XAttribute aSealed = item.Attribute("Sealed");

                XAttribute aReadOnly = item.Attribute("ReadOnly");

                if (aID != null && aType != null && aDisplayName != null &&

                    aName != null)

                    bool ishidden = false;

                    bool issealed = false;

                    bool isreadonly = false;

                    if (aHidden != null && aHidden.Value.ToString() == "TRUE") ishidden = true;

                    if (aSealed != null && aSealed.Value.ToString() == "TRUE") issealed = true;

                    if (aReadOnly != null && aReadOnly.Value.ToString() == "TRUE") isreadonly = true;

                    columns.Add(new SPColumnInfo(

                        aID.Value.ToString(),

                        aType.Value.ToString(),

                        aDisplayName.Value.ToString(),

                        aName.Value.ToString(),

                        ishidden, issealed, isreadonly));

            return columns;

        catch (Exception ex)

            throw ex;

    public static void createMetadataColumns(listsProxy.Lists sharePointLists, string listID)

        int createColumnsCount = 0;

        if (!Properties.Settings.Default.OPTION_CREATE_METADATA_COLUMNS) return;

        var cols = from c in SharePointExtensions.getListColumns(

                   sharePointLists, listID)

                   where c.Hidden == false && c.Sealed == false && c.ReadOnly == false

                   select c;

        Dictionary<string, SPColumnInfo> columns = cols.ToDictionary(c => c.Name);

        string newFieldsList = "";

        if (!columns.ContainsKey(Properties.Settings.Default.COL_SUBJECT))

            string subjectfield =

                @"<Method ID='1'><Field Type='Text' DisplayName='{0}' MaxLength='255'/></Method>";

            newFieldsList += string.Format(subjectfield, Properties.Settings.Default.COL_SUBJECT);

            createColumnsCount++;

        if (!columns.ContainsKey(Properties.Settings.Default.COL_TO))

            string subjectfield =

                @"<Method ID='2'><Field Type='Text' DisplayName='{0}' MaxLength='255'/></Method>";

            newFieldsList += string.Format(subjectfield, Properties.Settings.Default.COL_TO);

            createColumnsCount++;

        if (!columns.ContainsKey(Properties.Settings.Default.COL_CC))

            string subjectfield =

                @"<Method ID='3'><Field Type='Text' DisplayName='{0}' MaxLength='255'/></Method>";

            newFieldsList += string.Format(subjectfield, Properties.Settings.Default.COL_CC);

            createColumnsCount++;

        if (!columns.ContainsKey(Properties.Settings.Default.COL_BCC))

            string subjectfield =

                @"<Method ID='4'><Field Type='Text' DisplayName='{0}' MaxLength='255'/></Method>";

            newFieldsList += string.Format(subjectfield, Properties.Settings.Default.COL_BCC);

            createColumnsCount++;

        if (!columns.ContainsKey(Properties.Settings.Default.COL_FROM))

            string subjectfield =

                @"<Method ID='5'><Field Type='Text' DisplayName='{0}' MaxLength='255'/></Method>";

            newFieldsList += string.Format(subjectfield, Properties.Settings.Default.COL_FROM);

            createColumnsCount++;

        if (!columns.ContainsKey(Properties.Settings.Default.COL_SENT))

            string subjectfield =

                @"<Method ID='6'><Field Type='DateTime' DateOnly='FALSE' DisplayName='{0}'/></Method>";

            newFieldsList += string.Format(subjectfield, Properties.Settings.Default.COL_SENT);

            createColumnsCount++;

        if (!columns.ContainsKey(Properties.Settings.Default.COL_SIZE))

            string subjectfield =

                @"<Method ID='7'><Field Type='Number' DisplayName='{0}'/></Method>";

            newFieldsList += string.Format(subjectfield, Properties.Settings.Default.COL_SIZE);

            createColumnsCount++;

        if (!columns.ContainsKey(Properties.Settings.Default.COL_IMPORTANCE))

            string subjectfield =

                @"<Method ID='8'><Field Type='Choice' DisplayName='{0}'>;

                  <Default>{1}</Default>

                  <CHOICES>

                    <CHOICE>{2}</CHOICE>

                    <CHOICE>{3}</CHOICE>

                    <CHOICE>{4}</CHOICE>

                  </CHOICES>

                </Field></Method>"

            newFieldsList += string.Format(subjectfield,

                Properties.Settings.Default.COL_IMPORTANCE,

                Properties.Settings.Default.COL_IMPORTANCE_MEDIUM,

                Properties.Settings.Default.COL_IMPORTANCE_HIGH,

                Properties.Settings.Default.COL_IMPORTANCE_MEDIUM,

                Properties.Settings.Default.COL_IMPORTANCE_LOW);

            createColumnsCount++;

        if (createColumnsCount > 0)

            XmlNode ndList = sharePointLists.GetList(listID);

            XmlNode ndVersion = ndList.Attributes["Version"];

            XmlDocument xmlDoc = new System.Xml.XmlDocument();

            XmlNode ndNewFields = xmlDoc.CreateNode(XmlNodeType.Element, "Fields", "");

            ndNewFields.InnerXml = newFieldsList;

try

                XmlNode ndReturn =

                   sharePointLists.UpdateList(listID,

                   null, ndNewFields, null, null,

                   ndVersion.Value);

            catch (Exception ex)

                throw ex;

Y con esto ya estamos en disposición de mostrar un cuadro de diálogo al usuario, para que seleccione la ubicación en el servidor de SharePoint dónde quiere guardar los elementos de correo.

En el próximo post veremos cómo guardar los elementos de corro en la ubicación seleccionada, creando las columnas de metadatos (si así lo hemos definido), y actualizando el valor de éstas columnas para guardar los valores de los campos de correo (Asunto, De, Para, Fecha, Tamaño, etc.).

Os recuerdo que al terminar la serie publicaré la solución con el código completo, por si a alguien le sirve.

Espero no demorarme tanto en escribir el próximo post!

Nos vemos, un saludo desde Andorra!

** crossposting desde el blog de Lluís Franco en geeks.ms **

LINQ to SQL (SQL compaq también existe!)

lfranco — Tue, 24 Feb 2009 12:58:00 GMT

Esta mañana mi colega de penurias Toni Sala me preguntaba acerca de las posibilidades de usar LINQ to SQL con bases de datos SQL Compaq. Efectivamente, se puede hacer, es algo que probé en su momento y no había utilizado más. Sin embargo, lo que si que recordaba era que no es tan evidente como con sus hermanos mayores.

Bueno, al lío. Para este ejemplo vamos a usar la BD de ejemplo Northwind.sdf que instala Visual Studio 2008 (en mi caso la tengo ubicada en ‘C:\Archivos de programa\Microsoft SQL Server Compact Edition\v3.5\Samples’).

Una vez creado el proyecto de ejemplo (en mi caso lo llamaré ‘SqlCompaqLINQ’), creamos una carpeta ‘Data’ dentro de nuestro proyecto y agregamos la BD a nuestro proyecto mediante ‘Project/Add existing Item’:

Hasta aquí todo normal, pero la diferencia de SQlCompaq respecto a sus hermanos mayores está en que si ahora creamos un DataContext e intentamos arrastrar una tabla sobre él, aparecerá un mensaje de error un poco descorazonador:

No pasa nada, para estos casos podemos ir directamente a la herramienta SqlMetal (ya sabéis lo del poder del metal :-P), y generar el correspondiente fichero DBML mediante la línea de comandos. Para ello abrimos la consola de Visual Studio y ejecutamos el siguiente comando (desde nuestra carpeta ‘Data’):

SqlMetal.exe Northwind.sdf /dbml:NorthwindCE.dbml

Esto generará el diseñador con las clases correspondientes a las tablas de la BD de SQL Compaq, que a continuación agegaremos a nuestro proyecto también mediante ‘Project/Add existing Item’:

Ahora basta con crear una instancia del diseñador, generar nuestra instrucción LINQ to SQL y ¡a jugar!:

using SqlCompaqLINQ.Data;

...

string path = "Data Source=|DataDirectory|\\Data\\Northwind.sdf";

using(Northwind dc = new Northwind(path))

    var customers = from c in dc.Customers

                    orderby c.CompanyName

                    select c;

    listBox1.DataSource = customers.ToList();

    listBox1.DisplayMember = "CompanyName";

    listBox1.ValueMember = "CustomerID";

Un saludo desde Andorra,

** crossposting desde el blog de Lluís Franco en geeks.ms **

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (IV)

lfranco — Tue, 10 Feb 2009 15:31:00 GMT

Entradas anteriores de la serie:

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (I)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (II)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (III)

He estado un par de días sin poder continuar con la serie, pero es que el trabajo aprieta y no siempre nos podemos dedicar a lo que más nos gusta...

Recapitulando: Cosas que necesitamos para nuestro add-in:

Cómo crear un complemento para Office (VSTO). visto en el post anterior.
Cómo registrar acciones en los menús de la aplicación host (Outlook). Lo veremos ahora.
Cómo conectar con un servidor MOSS/WSS con diferentes credenciales de usuario (System.Net.NetworkCredential) Esto también lo veremos ahora.
Cómo acceder a los sitios y listas de un site de MOSS/WSS (servicios Web de SharePoint). visto en el post anterior.
Cómo interpretar la información XML devuelta por los servicios (LINQ to XML). Y esto también lo veremos ahora.
El resto de cosas las veremos en los próximos días...

Hoy nos centraremos en mostrar cómo agregar opciones a los menús de Outlook (para lanzar nuestras acciones personalizadas), ver cómo conectar con un sitio de SharePoint con las credenciales predeterminadas, o bien proporcionando un usuario y password. Y además veremos cómo interpretar el resultado devuelto por los servicios Web, ya que el usar LINQ to XML va a facilitarnos en mucho la tarea de lidiar con XML puro y duro.

Demos un vistazo al futuro, a lo que va a ser este Add-In (solo Bender puede viajar al futuro):

1 - Una vez registradas nuestras propias acciones en el menú de Outlook, éstas permitirán guardar los elementos selecionados:

2 – Aparecerá una ventana en la que podremos se leccionar la biblioteca de documentos y la carpeta destino:

3 – Una vez seleccionada la carpeta, mostraremos una ventana de progreso en un hilo separado para que el usuario pueda seguir interactuando con Outlook:

4 – Una vez terminado, si vamos a la biblioteca de documentos aparecerán los documentos (y más adelante también los metadatos):

Vayamos por partes:

Registrar acciones en un menú de Outlook:

Registrar el menú es sencillo, sólo debemos modificar el código del evento ‘ItemContextMenuDisplay’ (como ya vimos en el post anterior), y llamar a un método ‘RegisterMenu’ que se encarga de agregar nuestras acciones al menú contextual de Outlook.

void Application_ItemContextMenuDisplay(

    Microsoft.Office.Core.CommandBar CommandBar,

    Microsoft.Office.Interop.Outlook.Selection Selection)

    RegisterMenu(CommandBar, false);

void RegisterMenu(Microsoft.Office.Core.CommandBar CommandBar, bool IsFolder)

    Office.CommandBarPopup cmdSaveToMOSS =

        (Office.CommandBarPopup)CommandBar.FindControl(

        missing, missing, "STSMOSS", missing, missing);

    if (cmdSaveToMOSS == null)

        cmdSaveToMOSS = (Office.CommandBarPopup)CommandBar.Controls.Add(

                Office.MsoControlType.msoControlPopup, missing,

                missing, missing, false);

        if (cmdSaveToMOSS != null)

            cmdSaveToMOSS.Caption = Properties.Resources.CONTEXT_MENU_CAPTION;

            cmdSaveToMOSS.Tag = "STMOSS";

            cmdSaveToMOSS.BeginGroup = true;

            Office.CommandBarButton btnSaveToMOSS =

                (Office.CommandBarButton)cmdSaveToMOSS.Controls.Add(

                Office.MsoControlType.msoControlButton, missing, missing, missing, missing);

            btnSaveToMOSS.Caption = Properties.Resources.CONTEXT_MENU_SENDBUTTON;

            btnSaveToMOSS.FaceId = 65;

            btnSaveToMOSS.Tag = IsFolder.ToString();

            btnSaveToMOSS.Style = MsoButtonStyle.msoButtonIconAndCaption;

            btnSaveToMOSS.Picture = getImage();

            btnSaveToMOSS.Click += new Microsoft.Office.Core.

                _CommandBarButtonEvents_ClickEventHandler(saveToMOSS_Click);

            Office.CommandBarButton btnConfigurationMOSS =

                (Office.CommandBarButton)cmdSaveToMOSS.Controls.Add(

                Office.MsoControlType.msoControlButton, missing, missing, missing, missing);

            btnConfigurationMOSS.Caption = Properties.Resources.CONTEXT_MENU_CONFIGURATIONBUTTON;

            btnConfigurationMOSS.BeginGroup = true;

            btnConfigurationMOSS.Style = MsoButtonStyle.msoButtonIconAndCaption;

            btnConfigurationMOSS.Click += new Microsoft.Office.Core.

                _CommandBarButtonEvents_ClickEventHandler(configurationMOSS_Click);

            cmdSaveToMOSS.Visible = true;

Este código crea un elemento menú y le agrega dos opciones (‘btnSaveToMOSS’ y ‘btnConfigurationMOSS’). A continuación establece sus propiedades y asigna los event handlers a sendas rutinas que se ejecutarán al pulsar sobre ellas.

void saveToMOSS_Click(Microsoft.Office.Core.CommandBarButton Ctrl, ref bool CancelDefault)

    CancelDefault = true;

    MessageBox.Show("Save");

void configurationMOSS_Click(Microsoft.Office.Core.CommandBarButton Ctrl, ref bool CancelDefault)

    CancelDefault = true;

    MessageBox.Show("Config");

Conectar con un servidor MOSS/WSS con diferentes credenciales de usuario:

En algunas ocasiones tal vez nos interese conectar con un sitio de SharePoint y no hacer uso de las credenciales predeterminadas (por defecto el token del usuario de Windows). En estos casos, debemos hacer uso de la clase ‘System.Net.NetworkCredential’, pasando los valores de usuario y password (y opcionalmente dominio) para acceder al sitio. En este caso he creado unas sencillas funciones que devuelven un objeto de tipo ‘ICredentials’ que posteriormente usaremos en la propiedad ‘Credentials’ de los proxies de los servicios Web:

public static System.Net.ICredentials getCredentials()

    return System.Net.CredentialCache.DefaultCredentials;

public static System.Net.ICredentials getCredentials(string user, string password, string domain)

    return new System.Net.NetworkCredential(user, password, domain);

Interpretar el resultado devuelto por los servicios Web (LINQ to XML):

En el post anterior vimos que el resultado devuelto por los métodos de un servicio Web dista mucho de ser fácilmente interpretable, ya que nos devuelve un objeto de tipo XmlNode, de modo que debemos analizar el DOM para obtener el resultado deseado. En nuestro caso, vamos a realizar una llamada al método ‘GetWebCollection()’, que devuelve un XmlNode con los nombres de las webs (sites) de un sitio de SharePoint. Pero vamos a utilizar LINQ to XML para obtener sólo los elementos de un tipo determinado, y además vamos a obtener aquellos atributos que nos interesan. Y lo mejor es que todo se hace una sola sentencia:

public static List<SPSiteInfo> getSiteSubSites(websProxy.Webs sharePointWebs)

try

        XmlNode websResult = sharePointWebs.GetWebCollection();

        XDocument results = XDocument.Parse(websResult.OuterXml);

        XName name = XName.Get("Web", "http://schemas.microsoft.com/sharepoint/soap/");

        var webs = from item in results.Descendants(name)

                   select new SPSiteInfo

                       item.Attribute("Title").Value,

                       item.Attribute("Url").Value

);

        return webs.ToList();

    catch (Exception ex)

        throw ex;

A destacar en el código anterior el uso de un elemento XName para obtener sólo los elementos de tipo Web:

A continuación basta con seleccionar los atributos deseados de cada elemento XML (en nuestro caso título y url) e ir creando objetos que almacenaremos en una colección. Aquí utilizo una sencilla clase llamada ‘SPSiteInfo’ para devolver una lista genérica. Esta clase tiene sólo dos propiedades de tipo string (Title y URL) y un constructor en el que le pasamos ambos valores:

public class SPSiteInfo

    public string Title { get; set; }

    public string URL { get; set; }

    public SPSiteInfo()

//

    public SPSiteInfo(string title, string url)

        Title = title;

        URL = url;

De este modo, ya tenemos una función que nos devuelve una colección de objetos ‘SPSiteInfo’. Emplearemos este mismo procedimiento para recuperar las bibliotecas de documentos de un sitio, las carpetas de una biblioteca de documentos, e incluso las columnas de una biblioteca de documentos.

Pero ello lo veremos en el próximo post, que hay que volver a las trincheras... :-)

PD – Os recuerdo que al final de la serie publicaré el código fuente del proyecto de ejemplo.

** crossposting desde el blog de Lluís Franco en geeks.ms **

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (III)

lfranco — Wed, 04 Feb 2009 16:22:00 GMT

Entradas anteriores de la serie:

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (I)

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (II)

Bueno, vamos a empezar a trabajar en nuestro Add-In!

Aunque antes, una aclaración: Como la mayoría de vosotros ya sabéis, en realidad quién hace el trabajo sucio no soy yo. Yo sólo me llevo los millones y la fama, mientras que la ingrata tarea de picar código (que no gusta a nadie :-P) se la dejo a mi Bender. Efectivamente, acabáis de descubrir uno de los secretos mejor guardados: Detrás de un MVP siempre hay alguien haciendo el trabajo real mientras ellos se llevan el mérito... Esto ha sido así desde que el pionero Rubén Vigón enseñó a codificar a su gato con Visual Basic 3.0, y poco a poco la mayoría hemos ido ‘adoptando’ esta acertada filosofía, que en mi caso me ha permitido apartarme de estas tareas mundanas y dedicarme a mis viñedos y mi afición desmedida por la calceta.

Así que en cuanto le propuse la idea del Add-In a Bender, le pareció que debíamos ponernos a ello en seguida (seguramente animado por la visión de las 2 cajas de un chardonnay excelente que recibirá como compensación al terminar). De modo que vamos a empezar en seguida.

Nota: Al terminar la serie publicaré el proyecto de ejemplo con todo el código al completo.
Un poco de paciéncia porque lo voy a ir haciendo sobre la marcha, ok?

Creando un proyecto Add-In para Outlook 2007

Esta es la parte más sencilla, ya que con Visual Studio 2008 (supongo que todos lo tenéis actualizado con el SP1) se incorporan las plantillas básicas para crear un proyecto de este tipo. Basta con iniciar un proyecto nuevo, y dentro de la categoría ‘Office’ encontraréis las plantillas para la versión 2007.

Esto crea un proyecto C# con las referencias necesarias para ejecutarse como complemento de Outlook, y proporciona el esqueleto básico para interceptar los eventos que se producen al cargar y descargar nuestro complemento.

using Outlook = Microsoft.Office.Interop.Outlook;

using Office = Microsoft.Office.Core;

namespace OutlookToMOSS

    public partial class ThisAddIn

        private void ThisAddIn_Startup(object sender, System.EventArgs e)

        private void ThisAddIn_Shutdown(object sender, System.EventArgs e)

        #region VSTO generated code

        /// <summary>

        /// Required method for Designer support - do not modify

        /// the contents of this method with the code editor.

        /// </summary>

        private void InternalStartup()

            this.Startup += new System.EventHandler(ThisAddIn_Startup);

            this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);

        #endregion

Observar que hay una región de código generado por el diseñador, que es la encargada de suscribir los eventos ‘StartUp’ y ‘StartDown’. En estos eventos, posteriormente agregaremos el código para inicializar y destruir nuestras referencias a los servicios Web de SharePoint. Además para poder interactuar con Outlook interceptaremos además un par de eventos más llamados ‘ItemContextMenuDisplay’ y ’FolderContextMenuDisplay’, que se producen al mostrar los menús contextuales de Outlook (por ejemplo, al pulsar el botón derecho sobre una selección de elementos de correo).

Agregando referencias a los servicios Web de SharePoint

Lo primero es lo primero, así que ya que vamos a interactuar con SharePoint, vamos a agregar referencias Web a aquellos servicios que vamos a consumir. Aunque tenemos una lista de varios servicios Web, de entrada vamos a trabajar con estos dos, aunque probablemente añadiremos otros más adelante:

Webs Web Service: Para acceder a la colección de sitios Web de un sitio de SharePoint.
Lists Web Service: Para acceder a la colección de bibliotecas de documentos de un sitio.

Para crear la referencia debemos conocer la URL de nuestro SharePoint (por ejemplo http://moss). Y agregar una ‘Service Reference’ al proyecto. Esto mostrará el cuadro de diálogo para agregar servicios WCF, pero como en nuestro caso vamos a agregar una referencia a un servicio Web 2.0 hay que dar un rodeo, ir a la parte avanzada y especificar que queremos crear una ‘Web reference‘:

Pulsar en el botón para mostrar las características avanzadas:

Especificar que deseamos agregar una ‘Web reference’ y en la nueva ventana especificar la URL del servicio, que siempre sigue esta nomenclatura:

En nuestro caso:

http://moss/_vti_bin/Webs.asmx

http://moss/_vti_bin/Lists.asmx

Especificando el nombre (en mi caso tengo por costumbre llamarlos websProxy y listsProxy).

Una vez añadidas veremos que en el árbol del proyecto aparece un elemento llamado ‘Web References’ que contiene las dos referencias a los servicios Web.

Interceptando eventos de Outlook

Ahora, para hacerlo más interesante, antes de ejecutar vamos a interceptar el evento ‘ItemContextMenuDisplay’ que se produce cuando el usuario muestra el menú contextual de los elementos de correo (dicho de otro modo, selecciona uno o varios emails y pulsa botón derecho). Para ello modificaremos la sección generada por el diseñador, agergando la siguiente línea al método InternalStartUp():

this.Application.ItemContextMenuDisplay +=

    new Microsoft.Office.Interop.Outlook.ApplicationEvents_11_ItemContextMenuDisplayEventHandler(

    Application_ItemContextMenuDisplay);

Y lógicamente ahora crearemos el método que será llamado al dispararse el evento:

        void Application_ItemContextMenuDisplay(

            Microsoft.Office.Core.CommandBar CommandBar,

            Microsoft.Office.Interop.Outlook.Selection Selection)

            websProxy.Webs sharePointWebs;

            sharePointWebs = new websProxy.Webs();

            sharePointWebs.Credentials = System.Net.CredentialCache.DefaultCredentials;

            XmlNode webs = sharePointWebs.GetWebCollection();

Este código es provisional, pero nos servirá para ver como se debe llamar a un método de un servicio Web. Primeramente se declara y se crea el objeto, a continuación se especifican las credenciales (en este caso las predeterminadas) y a continuación se llama al método GetWebCollection(), el cual nos devuelve un objeto... “oh sorpresa! oh dolor! oh campos de soledad, mustios collados...”, un objeto de tipo XmlNode. Efectivamente, los servicios Web de SharePoint trabajan con XML a tutiplén, con lo cual ya te aviso de que si no te gusta trabajar con XML tienes dos opciones: Dejar ahora mismo de leer este artículo escrito por Bender y hacer como yo disfrutando la de vida alegre, o bien esperar al próximo post, en el que veremos como LINQ to XML puede hacernos la vida un poco más fácil.

Ahoravamos a establecer un punto de ruptura en la última línea de código para ver que retorna el método GetWebCollection().

Estamos listos para ejecutar?

Pues si, ahora vamos a probar que sucede cuando ejecutamos nuestro proyecto. Como es un Add-In de Outlook va a arrancar éste primero y cuando hagamos click con el botón derecho sobre un elemento de correo entrará en acción el depurador permitiéndonos inspeccionar el valor de la variable ‘webs’, el cual os muestro a continuación, para que os asusteis un poco (hacer click en la imagen para verla más grande):

Mañana espero poder continuar con la serie. Y veremos cómo agregar elementos a los menús de Outlook, y cómo LINQ to XML nos va a permitir trabajar más cómodamente con los datos devueltos por los métodos de los servicios Web. Que todos sabemos de las bondades de XML, pero trabajar con atributos nunca resulta tan sencillo como trabajar con colecciones de objetos genéricos, verdad?

Pues eso, mañana más... que ahora me toca manicura y luego clase de tenis :-P

** crossposting desde el blog de Lluís Franco en geeks.ms **

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (II)

lfranco — Tue, 03 Feb 2009 14:08:00 GMT

Entradas anteriores de la serie:

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (I)

Vale, vamos a empezar a escribir la carta a los reyes magos:

Queridos reyes magos,

Este año me he portado muy bien así que me pido un add-in para Outlook que sirva para guardar los correos en bibliotecas de documentos de SharePoint, y que tenga las siguientes cositas:

Que se integre con los menús de Outlook, para poder seleccionar varios correos y copiarlos a la biblioteca que yo elija.
Que funcione tanto para MOSS como para WSS, para poder guardar correos en un servidor WSS que tengo en hosting en USA.
Que permita cambiar la ubicación del servidor de SharePoint para poder guardar los correos en el que me interese.
Que permita cambiar las credenciales de usuario, para permitir conectarme a diferentes sitios.
Que se encargue de crear las columnas necesarias para guardar los metadatos del elementos de correo (De, Para, Asunto, Enviado).
Que cuando guardemos una cantidad importante de correos no detenga la ejecución de Outlook, y podamos seguir trabajando mientras éstos se copian.
Y un detalle importante: Que tenga control de versiones, por si guardo dos veces el mismo elemento que me mantenga un histórico.

Y para desarrollar algo así necesitaremos saber varias cosas, por ejemplo:

Cómo crear un complemento para Office (VSTO).
Cómo conectar con un servidor MOSS/WSS con diferentes credenciales de usuario (System.Net.NetworkCredential)
Cómo acceder a los sitios y listas de un site de MOSS/WSS (servicios Web de SharePoint).
Cómo interpretar la información XML devuelta por los servicios (LINQ to XML).
Cómo guardar un fichero en una biblioteca de documentos de SharePoint con control de versiones (DocLibHelper).
Cómo ejecutar distintos threads y mostrar el progreso (Callbacks).
Cómo distribuir nuestro complemento, creando un archivo MSI (Windows Installer packages).

Y seguramente me dejo unas cuantas cosillas… pero ya las iremos abordando a medida que nos las encontremos. Al fin y al cabo esto es un proyecto de ejemplo y personal, así que sintiéndolo mucho no voy a utilizar SCRUM ;-)

Un saludo y mañana prometo empezar con el tema!

** crossposting desde el blog de Lluís Franco en geeks.ms **

SharePoint 2007 + Outlook 2007: Guardar correos de forma masiva (I)

lfranco — Mon, 02 Feb 2009 11:16:00 GMT

Es obvio que SharePoint es uno de los mayores productos de Microsoft, y que ha supuesto una revolución en el entorno colaborativo empresarial. Hoy en día esta herramienta hace posible que la información fluya entre los integrantes de una organización, y eso ha aumentado mucho la productividad y los procesos de trabajo de la empresa, algo que siempre agradecen los gestores :-)

Es obvio también que una plataforma de este calibre tiene muchas cosas a mejorar, ya que es todavía un “recién nacido” (aunque lleve ya tres versiones como producto). De forma que hay unos cuantos huecos que deben rellenarse con horas de ardua programación... algo que desespera a más de uno. Mucha gente me pregunta “¿pero cómo es posible que esto no esté implementado?”, y mi respuesta acostumbra a ser “pueeees... no tengo ni idea chico, pero lo bueno es que disponemos de un modelo de objetos que hace posible que lo implementes tu mismo.”

La verdad es que es más que posible que muchas de estas pequeñas cositas se implementen en la futura y deseada siguiente versión (de la que muy pocos elegidos saben algo), pero hasta entonces nos encontramos con algunas cosas que hay que hacer ‘a mano’.

Precisamente la última con la que me he encontrado (para mi sorpresa) se trata de que la integración de Outlook 2007 con SharePoint 2007 no es todo lo buena que debería, o más bien que falta alguna característica que encuentro “básica”.

En este caso se trata de la clasificación de elementos de correo en bibliotecas de documentos de SharePoint. Sería estupendo poder clasificar nuestros correos en bibliotecas de documentos con un simple “Guardar como…”, pero esto sólo se puede realizar cuando guardamos los correos de forma individual, ya que deben guardarse como ficheros MSG. Resulta que por algún designio divino esta opción no está disponible cuando seleccionamos varios elementos, y claro, ya sabemos que no es una opción válida para un gestor que está muy ocupado intentando salvar el mundo ;-) y menos en los tiempos que corren, en los que hay que salir de esta crisis a golpe de reuniones de high-level y comités de dirección, y no estamos para dilapidar el tiempo en tareas repetitivas, verdad?

Bueno, al grano que me estoy yendo... el tema es que como no he encontrado una forma de hacerlo, me he propuesto crear un add-in para Outlook, que permita guardar elementos de correo en bibliotecas de documentos de SharePoint. Y a medida que lo vaya desarrollando iré posteando algunas de las cosas interesantes de este desarrollo (cómo crear un proyecto de add-in para Outlook con VSTO, cómo interactuar con la aplicación host, acceder a los servicios Web de SharePoint, cómo distribuir el Add-In, etc). Y al final postear el código de ejemplo o crear un proyecto en codeplex para la comunidad. De este modo servirá de ejemplo (aunque sea malo :-P) y tal vez a alguien más podrá serle útil.

En el próximo post empezaremos a planificar el desarrollo. Saludos y hasta pronto,

** crossposting desde el blog de Lluís Franco en geeks.ms **

Tip: Mostrar objetos relacionados en DevExpress GridControl

lfranco — Fri, 23 Jan 2009 12:15:00 GMT

:-)
Hola de nuevo,

Hoy os voy a mostrar un pequeño tip, muy útil si trabajáis con este fantástico control.

En muchas ocasiones nos encontramos con la necesidad de mostrar una serie de registros de una tabla, y también queremos mostrar información de otras tablas relacionadas. En estos casos existen varias soluciones: Leer los datos de ambas tablas con una instrucción JOIN en la base de datos y mostrar la información extendida en el grid, agregar a la vista un ‘ColumnEdit’ de tipo ComboBox o LookUpEdit y cargar los datos de la tabla relacionada, interceptar el evento ‘CustomColumnDisplayText’ de la columna y mostrar los valores que deseemos, y unos cuantos más que no comentaremos aquí.

Sin embargo existe una solución mucho más sencilla (aunque no he encontrado nada de documentación al respecto). Se trata de extender la propiedad FieldName de la columna siguiendo el esquema de nuestro DataContext (LINQ to SQL) o Model (LINQ to EF).

Partiendo de la base de que disponemos de un modelo o un contexto de datos como el siguiente:

Y deseamos obtener el resultado siguiente (observar que las columnas ‘Category’ y ‘Supplier’ muestran valores de las tablas relacionadas):

Pues es tan sencillo (*) como establecer la propiedad FieldName de la columna, escribiendo el nombre del campo completo incluyendo los nombres de los objetos relacionados (en nuestro caso Category.CategoryName y Supplier.CompanyName). Nota: Es posible extender esto encadenando las clases de nuestro modelo (yo por lo menos he llegado a encadenar hasta 4 tablas).

Y lo que más me gusta de esta solución respecto a las otras es que permite incluso el filtrado de los resultados, algo que cuando hacemos interceptando el evento ‘CustomColumnDisplayText’ no es posible.

En fin, si alguien no conocía este tip y usa este control, espero que le sea útil…

Saludos desde Andorra,

Nota: Olvidé mencionar que esta solución es idela para aquellos formularios de consulta, no en modo de entrada de datos (entonces usaríamos un LookUpEdit).

(*) Supongo que es necesario que esté activada la carga diferida, algo que en LINQ to SQL es así de forma predeterminada, aunque no en EF.

** crossposting desde el blog de Lluís Franco en geeks.ms **

Material del evento: Asentando las bases

lfranco — Tue, 30 Dec 2008 10:34:04 GMT

Ayer tuvimos el último evento del año en AndorraDotNet. Mientras llegan las fotos que hicieron algunos de los asistentes, aprovecho para publicar el material del evento, tanto la presentación como los proyectos de ejemplo.

La presentación la encontraréis aquí:

Y la solución de Visual Studio aquí:

Gracias por todo y nos vemos pronto!

** crossposting desde el blog de Lluís Franco en geeks.ms **