El blog de Lluis Franco : Utilidad

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 **

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 **

Folder size: Primer contacto

lfranco — Fri, 08 Aug 2008 12:09:51 GMT

Harto de buscar dónde se iba el espacio de mi disco duro, y con la sensación de que estaba malgastando un porrón de bytes (y os aseguro que no es en peliXculas), me puse a diseñar una herramienta que me mostrase lo que ocupa cada una de las carpetas de mi ordenador. De esto hace un par de días, y la verdad es que me he liado la manta a la cabeza :-P y al final el resultado es este:

Está enteramente escrito en C# 3.0 y aunque el funcionamiento es más sencillo que el mecanismo de un botijo (al fin y al cabo sólo recorre una estructura de carpetas y va procesando archivos), el resultado me gusta. Para compensar su sencillez le he añadido una interfaz cool (al menos para mí :-P), multithreading en la búsqueda, que a su vez hace uso de llamadas al FindFirstFile y FindNextFile para mejorar la performance... Aunque seguro que mi amigo el rano, belmonte de pro, me dice que si quiero ver performance me deje de tonterías y vuelva al C++ duro. Y os juro y perjuro que ya no me acuerdo de cómo se cocinaba con punteros. Además el resultado puede imprimirse o también exportar a Excel o PDF, y también muestra una lista de posibles errores producidos durante el análisis de la(s) carpeta(s), que mayormente son de acceso a ciertos elementos de sistema (o ubicaciones de red con permisos NTFS).

Si a alguien le apetece probarlo os lo podéis instalar desde esta ubicación:

http://utilities.ordeeno.com/foldersize/

El único requisito es el Framework 3.5, y si no lo tenéis instalado el programa de instalación muy amablemente lo hará por vosotros (eso si, tarda un ratito).

La licencia es beerware, lo cual quiere decir que si te gusta y lo usas... deberás invitarme al menos a una cerveza. Y si es con papas, mejor que mejor!

Bye @ home,

PD - Lo he probado en XP y Vista Ultimate y de momento no le he encontrado ningún bug grave, pero si vosotros lo hacéis podéis contactar conmigo aquí.

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

Accediendo al directorio activo de la organización desde .NET (II)

lfranco — Mon, 30 Jun 2008 13:53:07 GMT

En el post anterior vimos que en ocasiones nuestra aplicación deberá acceder a los datos que contiene el directorio activo de nuestra organización, ya sea para buscar elementos, validar credenciales, etc.

Hoy nos centraremos en los objetos del framework que nos permiten realizar esto, empezando por el objeto WindowsIdentity, que nos acompaña desde la versión 1.0 del framework, y que representa un usuario de Windows.

WindowsIdentity

Representa un usuario de Windows. Dispone de un método GetCurrent() que devuelve una referencia al usuario de Windows que está ejecutando la aplicación y que por defecto será el usuario actual de Windows.

En nuestro ejercicio vamos a utilizar este objeto para mostrar en la barra de estado algo de información sobre el usuario actual. El nombre y token, así como el contexto de suplantación y diversa información cómo si está autenticado, es de sistema, etc.

El código es muy sencillo y para usarlo sólo debemos tener en cuenta haber importado el espacio de nombres System.Security.Principal:

private void RefreshUserInformation()

    WindowsIdentity user = WindowsIdentity.GetCurrent();

    lblUser.Text = string.Format("User: {0}", user.Name);

    lblToken.Text = string.Format("Token: {0}", user.Token.ToString());

    lblImpersonating.Text = string.Format("Impersonating: {0}", user.ImpersonationLevel.ToString());

    lblIsAnonymous.Text = string.Format("Is Anonymous: {0}", user.IsAnonymous.ToString());

    lblIsAuthenticated.Text = string.Format("Is Authenticated: {0}", user.IsAuthenticated.ToString());

    lblIsGuest.Text = string.Format("Is Guest: {0}", user.IsGuest.ToString());

    lblIsSystem.Text = string.Format("Is System: {0}", user.IsSystem.ToString());

    if (sec.ImpersonationContext == null)

        cmdImpersonateApplicationAsUser.Enabled = true;

        lblUser.ForeColor = Color.Black;

        lblImpersonating.ForeColor = Color.Black;

    else

        cmdImpersonateApplicationAsUser.Enabled = false;

        lblUser.ForeColor = Color.Red;

        lblImpersonating.ForeColor = Color.Red;

    cmdUndoImpersonation.Enabled = !cmdImpersonateApplicationAsUser.Enabled;

Lo único a destacar es que en caso de que exista suplantación (ImpersonationContext distinto de nulo), mostraremos algunos campos en color rojo, para destacar que este usuario es distinto del que inició sesión en Windows.

LDAPServices

En este proyecto he creado una clase que proporciona una serie de funcionalidades comunes, su nombre es LDAPServices y encapsula una serie de métodos estáticos, para facilitar el trabajo con LDAP. En los próximos posts detallaremos el uso de estos métodos:

SecurityContext

También aparece la clase llamada SecurityContext que ya hemos visto en la serie de posts sobre acceder a la caché de IE, que encapsula toda la lógica necesaria para impersonar nuestra aplicación y que se ejecute con otras credenciales de usuario de Windows.

Esta clase expone una propiedad de tipo WindowsImpersonationContext que devuelve información sobre si está realizando suplantación, y que en caso afirmativo permite terminarla mediante el método Undo(). También expone dos métodos LogonUser y ImpersonateUser, que permiten respectivamente validar unas credenciales de usuario contra un dominio y empezar un contexto de suplantación.

En el próximo post veremos cómo realizar esta suplantación y cómo recabar más información del usuario actual (por ejemplo a que grupos de Windows pertenece el usuario actual).

Hasta entonces!

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

Accediendo al directorio activo de la organización desde .NET (I)

lfranco — Wed, 11 Jun 2008 18:16:35 GMT

Creo que me estoy aficionando a las series ~~de posts no de la tele~~, ya que acabo de terminar la serie de artículos acerca de cómo acceder a la caché de Internet Explorer y ya estoy planteándome una nueva, sobre acceder al directorio activo mediante una aplicación realizada con C#. Esta serie, al igual que la anterior intentará ser lo más directa y práctica posible, y del mismo modo al final de la serie publicaré el código completo del ejemplo para su descarga.

El motivo...

...de esta serie es porque tanto en los foros como en los grupos de notícias, es muy común encontrar preguntas muy variadas acerca de cómo acceder a LDAP desde una aplicación .NET. Así que me he planteado empezar una serie de posts en los que mostraremos varios ejemplos: Mostrar información del usuario actual de Windows, averiguar los grupos a los que pertenece, validar credenciales contra un dominio para saber si son correctas, impersonar nuestra aplicación para que se ejecute con las credenciales de otro usuario, buscar usuarios o grupos en LDAP, extraer la lista de propiedades del objeto usuario, etc.

¿LDAP o Directorio Activo?

Antes de empezar quiero hacer una aclaración: ¿Es lo mismo LDAP que Directorio Activo? No, no es lo mismo.

LDAP es el acrónimo de (Lightweight Directory Access Protocol) que es es un protocolo a nivel de aplicación que permite el acceso a un servicio de directorio ordenado y distribuido para buscar diversa información en un entorno de red. Habitualmente se utiliza para acceder a la información almacenada de usuarios, grupos y equipos de una organizació y existen muchas implementaciones de este protocolo, desde Microsoft hasta Novell pasando por Red Hat, iPlanet u OpenLDAP.

El directorio Activo o AD es la implementación de LDAP realizada por Microsoft en su família Windows Server. Al igual que LDAP permite acceder a distintos tipos de objetos almacenados que representan los elementos de la organización. Cada uno de estos objetos tendrá atributos que permiten identificarlos en modo unívoco (por ejemplo, los usuarios tendrán campo "nombre", campo "email", etc..., las impresoras de red tendrán campo "nombre", campo "fabricante", campo "modelo", campo "usuarios que pueden acceder", etc). Toda esta información queda almacenada en Active Directory replicándose de forma automática entre todos los servidores que controlan el acceso al dominio.

Situaciones cotidianas

Nosotros los desarrolladores, como creadores de aplicaciones que deben coexistir en un entorno corporativo, cada vez nos encontramos en más ocasiones en las que nuestra aplicación debe utilizar los usuarios y grupos del AD de la empresa, en lugar de almacenar una base de datos propia de usuarios y grupos. Incluso me atrevería a decir que la frontera entre una aplicación madura, de uso corporativo, y que se integre con otras aplicaciones y servicios, a veces estriba en detalles como éste.

Hoy en día cada vez más empresas disponen de la figura del administrador del AD, que gestiona todos los datos de los empleados de la misma, de modo que ¿para que van a mantener otra base de datos con los usuarios de una aplicación, si éstos ya existen en el AD? Incluso puede ser peor ¿os imagináis cuántas aplicaciones funcionan de este modo? ¿Debemos mantener X bases de datos de usuarios por X aplicaciones? Esto puede ser el caos... ¡imaginaos la de datos duplicados que existen y lo difícil que resulta mantenerlos!

Gracias al .NET framework, hoy en día podemos integrar nuestras aplicaciones con el AD de la empresa, de forma que podamos aprovechar la ventaja de contar con un repositorio centralizado. De este modo podremos dejar en manos del administrador del AD la creación de usuarios, grupos y cómo se relacionan entre ellos, y nosotros encargarnos de lo que realimente nos importa: La aplicación.

En el próximo post empezaremos a construir nuestra aplicación de ejemplo, y para ello contaremos con la ayuda del namespace System.Security.Principal y de System.DirectoryServices... hasta entonces!

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

Acceder a la caché de Internet Explorer (V y final)

lfranco — Tue, 10 Jun 2008 14:12:31 GMT

Éste es el último post de esta serie, en la cual se ha desarrollado un proyecto de ejemplo de cómo acceder a la caché de archivos temporales de Internet Explorer. De hecho, he aprovechado la excusa para montar un pequeño proyecto de ejemplo en el que poder enseñar varias cosas que tenía en mente y por falta de tiempo no podía postear.

ASí pues en éste ejercicio hemos mostrado entre otras cosas cómo:

Utilizar el API para acceder a los archivos temporales de Internet (post 1)
Persistir objetos .NET en ficheros XML mediante serialización (post 2)
Impersonar, para ejecutar temporalmente muestra aplicación con las credenciales de otro usuario (post 3)
Crear y distribuir nuestra aplicación como un servicio de Windows (post 4)

Y aquí os dejo el código completo del ejemplo:

Espero que os guste,

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

Acceder a la caché de Internet Explorer (IV)

lfranco — Fri, 30 May 2008 16:22:52 GMT

En los dos primeros artículos pudimos ver los objetos del API de Windows que íbamos a usar para poder acceder a la caché de los archivos temporales de Internet, cómo persistir estos datos en formato XML, y finalmente cómo permitir que temporalmente nuestra aplicacación se ejecute con las credenciales de otro usuario, para poder realizar una serie de acciones que de otro modo no podría efectuar por falta de privilegios.

Siguiendo con el objetivo de este ejercicio hoy vamos a encapsular la lógica de negocio de nuestra aplicación en forma de servicio de Windows, y éste va a encargarse de realizar una consulta a la caché de Internet de nuestro ordenador cada X tiempo (configurable mediante un fichero XML).

Lo primero de todo va a ser construir la base de nuestro servicio mediante un proyecto de tipo Windows Service. Esta plantilla nos genera un proyecto con un componente de tipo ServiceBase, que servirá para ir construyendo nuestro pequeño juguetito.

A continuación vamos a cambiar el nombre al servicio, en nuestro caso lo llamaremos "IECacheQueryService". Y posteriormente estableceremos a True los valores de las propiedades CanPauseAndContinue y CanShutdown, para poder pausar y detener nuestro servicio en tiempo de ejecución.

Importante: Comprobar que el nombre sel servicio se ha cambiado correctamente en el punto de entrada de la aplicación (si no fuese así tendremos que modificarlo manualmente):

static class Program

        static void Main()

            ServiceBase[] ServicesToRun;

            ServicesToRun = new ServiceBase[]

                new IECacheQueryService()

};

            ServiceBase.Run(ServicesToRun);

Implementando funcionalidad al servicio:

De momento el servicio será capaz de iniciarse, pero no realizará nada. Ahora debemos dotarlo de funcionalidad, y para ello vamos a crear un temporizador que se encargue de realizar una tarea cada X tiempo (por defecto una hora). Éste lo crearemos como un miembro dentro de nuestra clase:

public partial class IECacheQueryService : ServiceBase

    private Timer clock = new Timer();

Y lo usaremos desde el constructor de la misma, así como en los eventos OnStart y OnStop. Observar que en el constructor lo inicializamos con un valor que proviene del fichero de configuración del proyecto (propiedades del proyecto/settings) llamado TimerInterval y se ha establecido a un valor de 3.600.000 (1 hora en milisegundos).

public IECacheQueryService()

    InitializeComponent();

    clock = new Timer(Properties.Settings.Default.TimerInterval);

    clock.Elapsed += new ElapsedEventHandler(clock_Elapsed);

    clock.Enabled = true;

    //...

protected override void OnStart(string[] args)

    ExecuteQuery();

    clock.Start();

    //...

protected override void OnStop()

    clock.Stop();

Del mismo modo también especificamos el manejador de evento asociado que se ejecutará cada vez que se cumpla este intervalo de tiempo (clock_Elapsed). Éste será el corazón de nuestro servicio y será el encargado de invocar la consulta a la caché de IE:

void clock_Elapsed(object sender, ElapsedEventArgs e)

try

            ExecuteQuery();

        catch (Exception ex)

            appEventLog.WriteEntry("Exception: " + ex.Message,

                EventLogEntryType.Error);

Simple verdad? Ahora vamos a construir este método ExecuteQuery a apartir de las piezas que vimos en anteriores entradas de la misma serie. No os preocupeis que en el último post estará un enlace al código completo del ejemplo (incluido el instalable).

Que hace exactamente este método?

Primero de todo crea un objeto de tipo StopWatch para medir con precisión el tiempo que transcurre en la ejecución del mismo.
Llama al método getResults que se encarga de efectuar la consulta y devolver un objeto que es una lista genérica de entradas de la caché.
Construye el nombre de fichero en el que guardaremos los resultados y llama al método saveResults, encargado de realizar la suplantación de identidad y serializar los resultados en el fichero antes mencionado.

private void ExecuteQuery()

try

        Stopwatch watch = new Stopwatch();

        watch.Start();

        List<IECacheEntry> results = getResults(

            Properties.Settings.Default.SearchPattern);

        string filename = string.Format("{0}{1}_{2}.xml",

            Properties.Settings.Default.TargetPathLocation,

            Environment.MachineName,

            DateTime.Now.ToString("ddMMyyyy_hhmm"));

        watch.Stop();

        TimeSpan ts = watch.Elapsed;

        saveResults(results, filename);

        appEventLog.WriteEntry(string.Format(

            "Query executed successfully at {0} in '{1}' by user '{2}'. Elapsed time (ms): {3}",

            DateTime.Now.ToString(), Environment.MachineName,

            WindowsIdentity.GetCurrent().Name,ts.Milliseconds));

    catch (Exception ex)

        appEventLog.WriteEntry("Exception: " + ex.Message,

            EventLogEntryType.Error);

Está el servicio terminado? Bueno, si asumimos que el código está completo y funciona sin errores, sí, lo está :-P

Y ahora cómo lo probamos? Pues... bueno, para probarlo antes tenemos que instalarlo.

Agregando los elementos necesarios para instalar el servicio:

No he encontrado demasiada documentación al respecto, de modo que intentaré mostrar los pasos a seguir mediante capturas de pantalla.

Vamos a agregar un elemento que nos permita distribuir el servicio:

Le agregaremos dos componentes serviceProcessInstaller y serviceInstaller (es posible que no aparezcan en la barra de herramientas, así que tendremos que agregarlos mediante la opción "Choose Items..."

A continuación los configuraremos del siguiente modo:

Control	Propiedad	Valor
serviceProcessInstaller1	Account	LocalSystem (*)
serviceProcessInstaller1	Parent	Installer1
serviceInstaller1	Description	Internet Explorer Query Cache
serviceInstaller1	Display Name	Internet Explorer Query Cache
serviceInstaller1	Parent	Installer1
serviceInstaller1	ServiceName	IEQueryCache
serviceInstaller1	StartType	Automatic

(*) Habitualmente se utilizará siempre la cuenta con menos nivel de privilegios (LocalService), pero en nuestro caso necesitamos acceder a la caché de IE, de modo que es posible que incluso tengamos que configurar la cuenta de un usuario de windows con suficientes permisos.

Cruzamos los dedos, compilamos el proyecto y vamos a agegar un proyecto de instalación a la solución.

Creando el proyecto de instalación:

Agregaremos un proyecto de tipo Setup and deployment, que será el encargado de instalar nuestro servicio en las estaciones Windows que deseamos monitorizar.

Agregamos la salida del proyecto anterior al nuevo proyecto de instalación:

Ahora mostraremos la ventana de "custom actions" para agregar como acción al instalador la salida de nuestro proyecto de servicio de Windows.

Una vez realizado esto ya podemos compilar el proyecto de instalación e instalarlo en las estaciones cliente. Si quereis instalarlo en vuestra estación para probarlo y configurarlo adecuadamente, la opción más sencilla es seleccionar la opción Install del menú contextual del proyecto de instalación, en el explorador de proyectos.

Una vez instalado, aparecerá en el administrador de servicios, para que podamos configurarlo del modo deseado. En este caso particular, si deseamos monitorizar la caché de un usuario en particular, deberemos usar las credenciales de éste usuario, ya que si no el S.O. no será capaz de montar el fichero Index.dat correspondiente a la caché de Internet Explorer.

Bueno, hasta aquí ha llegado este ejemplo. En el próximo post haremos un resumen de lo que se ha visto hasta ahora y publicaré un enlace con el código completo del proyecto para que sirva de ejemplo (o de mal ejemplo :-P).

Saludos desde andorra,

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

Acceder a la caché de Internet Explorer (II)

lfranco — Tue, 20 May 2008 17:07:25 GMT

:-/
Hola de nuevo,

Siento haber tardado más de lo previsto en publicar este post, pero hemos tenido un fallecimiento en la familia este fin de semana y todavía andamos un poco descolocados. De todos modos, siguiendo con el hilo del primer post de esta serie, vamos a ver como leer los valores de los archivos temporales de Internet (imágenes que son almacenadas en caché, cookies, sitios visitados, etc.). Para acceder al contenido de esta caché vamos a usar un par de llamadas al API de windows y vamos a guardar el contenido de estas consultas en un medio persistente para su posterior análisis.

El objetivo de todo esto:

Nuestro objetivo va a consistir en recoger información de la caché cada X tiempo (supongamos cada hora), y mediante serialización persistirla en ficheros XML en una ubicación remota. Además, para complicarlo un poquito más vamos a hacer que esta ubicación no sea accesible desde el usuario actual, de modo que debamos impersonar otro inicio de sesión que si tenga permisos sobre esta ubicación. Todo esto, lo encapsularemos como un servicio de Windows y crearemos un proyecto de instalación que podremos distribuir en los clientes que deseamos inspeccionar.

Una vez terminado este ejercicio habremos mostrado varias cosas como:

Acceder a la caché de Internet Explorer
Serializar objetos a ficheros XML
Impersonar la ejecución de nuestra aplicación con otro usuario
Crear un servicio de Windows que ejecute un proceso cada X tiempo

De todos modos me gustaría dejar clara una cosa, para que nadie me malinterprete:

** El objetivo de todo esto no es ni mucho menos crear una herramienta para espiar a nadie, si no que lo he considerado más bien como un projecto que reune varias cosillas interesantes a explicar, un modo de reunirlas bajo un mismo ejercicio **

Preparando el terreno:

El primer paso va a ser declarar una clase que almacene la información de las entradas devueltas por las funciones FindFirstUrlCacheEntry y FindNextUrlCacheEntry.

[Serializable]

public class IECacheEntry

    public string url;

    public string size;

    public string lastAccessTime;

    public string lastModifiedTime;

    public string expireTime;

    public string filename;

    public IECacheEntry()

    public IECacheEntry(

        string _url,

        string _size,

        string _lastAccessTime,

        string _lastModifiedTime,

        string _expireTime,

        string _filename)

        url = _url;

        size = _size;

        lastAccessTime = _lastAccessTime;

        lastModifiedTime = _lastModifiedTime;

        expireTime = _expireTime;

        filename = _filename;

Esta clase la vamos a usar conjuntamente con esta clase, que identifica la consulta y recoge los datos que se guardarán cada vez que se ejecute la consulta a la caché. Esta clase también la decoraremos con el atributo serializable para posteriormante poder persistirla a un fichero XML:

[Serializable]

public class IECacheQuery

    public IECacheQuery() { }

    public string hostname = string.Empty;

    public string username = string.Empty;

    public DateTime date = DateTime.Now;

    public List<IECacheEntry> results;

Empezando a ensamblar las piezas:

EL corazón de este ejercicio consiste en esta pequeña función "getResults", que a partir de una cadena que contiene el patrón de búsqueda devuelve todas las instancias de la caché que coinciden con ésta. Este patrón de búsqueda puede contener el valor "cookies", "visited", una URL en concreto o bien NULL (que devuelve todos los valores de la caché). A continuación estos resultados se almacenan en una lista genérica que se devuelve como valor de retorno de la función.

Nota 1: Este código se ha realizado con compatibilidad con estaciones Windows 2000 que admiten versiones del Framework hasta la 2.0, de modo lamentablemente que no se han podido utilizar las bondades del Framework 3.5 (en particular he echado mucho de menos a LINQ to objects).

Nota 2 : En el código pueden observarse llamadas a funciones que no han sido descritas en el artículo (como el método ToStringFromFileTime en el código siguiente). Sin embargo estas funciones si pueden encontrarse en el código completo del ejemplo que se podrá descargar al final de la serie.

private List<IECacheEntry> getResults(string patternText)

    List<IECacheEntry> listresults = new List<IECacheEntry>();

    List<IECacheAPI.INTERNET_CACHE_ENTRY_INFO> results =

        IECacheAPI.FindUrlCacheEntries(patternText);

    foreach (IECacheAPI.INTERNET_CACHE_ENTRY_INFO result in results)

        IECacheEntry entry = new IECacheEntry();

        listresults.Add(

            new IECacheEntry

                    result.lpszSourceUrlName,

                    ((((Int64)result.dwSizeHigh) << 32) + result.dwSizeLow).ToString(),

                    Win32API.ToStringFromFileTime(result.LastAccessTime),

                    Win32API.ToStringFromFileTime(result.LastModifiedTime),

                    Win32API.ToStringFromFileTime(result.ExpireTime),

                    result.lpszLocalFileName

);

    return listresults;

Bien, de momento ya tenemos la función encargada de devolver los resultados de la caché, ahora ¿que hacemos con ellos?

Persistir objetos, que facil es con .NET!

Serializar objetos a XML es muy pero que muy sencillo. De hecho en nuestro caso ni siquiera vamos a aplicar un formateador SOAP ni binario, y tampoco vamos a aplicar atributos para serializar miembros de clases como nodos o atributos. En este caso vamos a usar la serialización del siguiente modo:

public sealed class Manager

        public static void Save(IECacheQuery query, string pfilename)

try

                XmlSerializer xmlDoc = new XmlSerializer(typeof(IECacheQuery));

                StreamWriter sw = new StreamWriter(pfilename);

                xmlDoc.Serialize(sw, query);

                sw.Close();

            catch (Exception ex)

                throw ex;

A esta función se le pasan dos argumentos, el objeto que deseamos persistir i el nombre del archivo XML en el que se quiere persistir. En ella se crea un objeto XmlSerializer preparado para el tipo de objeto IECacheQuery, a continuación se crea un Stream al fichero XML para serializar el objeto. A continuación se cierra el Stream y se acabó lo que se daba.

Qué? Facil verdad? Esta es una de las maravillas que me cautivaron cuando empecé con .NET (y es que con anterioridad había que hacer maravillas para poder realizar este tipo de cosas).

Próximos pasos:

De momento ya tenemos la función que devuelve resultados de la caché y tenemos un modo de persistir un objeto en un fichero XML. A continuación, después de la publicidad (o más bien en el próximo post), mostraremos como Impersonar nuestra aplicación para que se ejecute como otro usuario, a fin de tener acceso a una supuesta ubicación de red en la que gusrdar los ficheros de resultados.

Hasta el próximo post.

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

Acceder a la caché de Internet Explorer (I)

lfranco — Thu, 15 May 2008 16:59:45 GMT

En algunos casos puede ser interesante acceder a la caché de navegación de Internet Explorer. Por ejemplo, para poder guardar un registro de los sitios que visitan los usuarios de nuestra organización sin tener que montar un ISA server o similar.

Para ello, y como todavía no he encontrado nada implementado en el propio Framework, vamos a hacer uso de algunos elementos del API de Windows. Ese gran amigo que todavía nos sigue sacando las castañas del fuego algunas veces... :-D

El punto de partida:

Cuando accedemos a la carpeta de archivos temporales de Internet, podemos eliminar el contenido o cambiar la ubicación de la carpeta que utilizamos para almacenar este información:

Incluso si pulsamos la opción de ver archivos, el explorador nos muestra una vista similar a esto:

Sin embargo, esta vista se genera automáticamente a partir del contenido de un fichero llamado Index.dat, que se encuentra en la carpeta "Archivos temporales de Internet\Content.IEX", siendo X la versión de IE del sistema. De modo que, para poder acceder a la información contenida en este fichero no nos queda más remedio que utilizar algunas funciones del API de Windows.

Presentando a los protagonistas:

Como os decía anteriormente, a falta de poder usar código manejado vamos a utilizar los ladrillos del propio S.O.

Esta estructura representa un elemento dentro de la caché de Internet.

[StructLayout(LayoutKind.Sequential)]

public struct INTERNET_CACHE_ENTRY_INFO

    public UInt32 dwStructSize;

    public string lpszSourceUrlName;

    public string lpszLocalFileName;

    public UInt32 CacheEntryType;

    public UInt32 dwUseCount;

    public UInt32 dwHitRate;

    public UInt32 dwSizeLow;

    public UInt32 dwSizeHigh;

    public Win32API.FILETIME LastModifiedTime;

    public Win32API.FILETIME ExpireTime;

    public Win32API.FILETIME LastAccessTime;

    public Win32API.FILETIME LastSyncTime;

    public IntPtr lpHeaderInfo;

    public UInt32 dwHeaderInfoSize;

    public string lpszFileExtension;

    public UInt32 dwExemptDelta;

};

Más información acerca de esta estructura en:

INTERNET_CACHE_ENTRY_INFO Structure

http://msdn.microsoft.com/en-us/library/aa385134(VS.85).aspx

También nos basaremos en estas dos funciones, encargadas de devolver un puntero a un elemento del tipo INTERNET_CACHE_ENTRY_INFO dentro de la caché. La primera de ellas devuelve el primer valor encontrado en la caché, a partir de un puntero a una cadena que representa el patrón a buscar. Mientras que la segunda recibe el manejador devuelto por la primera llamada a FindFirstUrlCacheEntry.

[DllImport("wininet.dll", SetLastError=true)]

private static extern IntPtr FindFirstUrlCacheEntry(

  string lpszUrlSearchPattern, IntPtr lpFirstCacheEntryInfo,

  out UInt32 lpdwFirstCacheEntryInfoBufferSize );

[DllImport("wininet.dll", SetLastError=true)]

private static extern long FindNextUrlCacheEntry(

  IntPtr hEnumHandle, IntPtr lpNextCacheEntryInfo,

  out UInt32 lpdwNextCacheEntryInfoBufferSize );

Podéis encontrar más información acerca de ellas en:

FindNextUrlCacheEntry Function
http://msdn.microsoft.com/en-us/library/aa384049(VS.85).aspx

FindFirstUrlCacheEntry Function
http://msdn.microsoft.com/en-us/library/aa384026(VS.85).aspx

Y ahora que?

Pues ahora nada, que me he quedado sin tiempo... hasta aquí este primer post. Mañana continuaremos con la construcción de un pequeño proyecto de ejemplo que utiliza estas funciones para acceder a la caché de Internet y muestre el contenido en pantalla. Y si da tiempo, sería interesante crear una aplicación o servicio que vaya monitorizando y guardando este contenido en algún medio persistente (tal vez XML o una base de datos).

Hasta mañana!

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

Evaluación: Colligo Contributor 3.0 Pro

lfranco — Fri, 28 Mar 2008 16:33:11 GMT

Siguiendo con la serie de posts de evaluación de productos, que todo sea dicho la he tenido un poco abandonada, hoy quiero hablaros de un producto que realmente me ha evitado un montón de trabajo. Se trata de Colligo Contributor 3.0 Pro y es un cliente de escritorio de SharePoint que permite hacer un montón de cosas útiles, como por ejemplo:

Sincronizar el contenido de librerías de documentos en una caché guardada en el cliente, para así trabajar de forma desconectada (a mi juicio mejor que Groove). Ideal para usuarios con portátiles.
Soporte para Drag & Drop, de modo que si arrastramos un archivo a una biblioteca de documentos se añadirá de forma automática. Esto es válido también para mensajes de correo electrónico e incluso los archivos adjuntos que contienen. Por si fuera poco, si nuestra biblioteca tiene columnas como "From", "To" o "Subject", la aplicación mapeará automáticamente las propiedades como valores de éstas columnas. Great!
Pero a mi juicio la mejor de todas (o la que más trabajo me ha ahorrado), es la de subir múltiples archivos de golpe a una biblioteca y poder asignarles un tipo de contenido y los valores de las columnas a la vez. Esto es una característica que cuando una empresa se enfrenta a una migración de cientos de miles de documentos, se agradece sobremanera.

De hecho, no podía creerme que SharePoint no incorpore esta característica 'de fábrica', ya que es vital para cualquier empresa que desea traspasar toda su documentación a este fantástico entorno de trabajo. Es totalmente inviable pensar en subir más de 100.000 documentos uno a uno para modificar sus metadatos.

Así que, hace un par de semanas empecé a plantearme la posibilidad de realizar yo mismo una utilidad para éste propósito. De modo que hablé con Jorge Serrano y con Carlos Segura, que son unos fenómenos de los que se están peleando a diario con SharePoint y les encantó la idea, ya que es una necesidad que tienen muchas empresas en este momento (Carlos incluso me planteó la posibilidad de empezar un proyecto en CodePlex :-P).

Dicho y hecho, empecé a tirar cuatro líneas de código para ver si era factible (y razonablemente sencillo, que todos vamos muy apurados de tiempo) conectar con el WebService de SharePoint apropiado, obtener y modificar el contenido de listas y bibliotecas, acceder a los tipos de contenido y sobretodo a los valores de las columnas que contienen. Y la verdad es que no es nada complicado, espero publicar pronto algún post al respecto.

Peeeeeeero, cuando más animado estaba y me disponía a contactar de nuevo con esos dos elementos me llegó un mail de Barry W. Jinks, de Colligo avisándome del release de la nueva versión 3.0 y mandándome una licencia NFR (es un tipo de licencia Not For Resale para MVPs de Microsoft) para su evaluación. Empecé a probar el producto y la verdad es que tras un par de días ya tengo claro que no voy a continuar con mi utilidad, puesto que esta aplicación tiene casi todo lo que necesitaba.

La verdad es que cosas así pasan pocas veces, así que quería compartirlo con vosotros y si alguno se encuentra en la misma situación os aconsejo darle un buen vistazo al producto. Vale la pena...

Link: Colligo Networks – Collaboration Made Easy

Un saludo desde Andorra,

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

Evaluación: RedGate Software - SQL Toolbelt

lfranco — Tue, 19 Feb 2008 20:07:34 GMT

Vamos con el primero de la serie de posts de evaluación de herramientas!

Existen una serie de herramientas que considero básicas en el banco de trabajo de un DBA que se precie, ya que pueden ahorrar un sinfín de quebraderos de cabeza. Enter ellas se encuentran las herramientas de RedGate Software para SQL Server y .NET (http://www.red-gate.com/). Ha sido una agradable sorpresa descubrir esta suite de herramientas, que reúne un total de 10 'perlas', a cada cual más adictiva.

Lástima no haberlos conocido hace un tiempo... La verdad es que hace un año estuve desarrollando una herramienta muy parecida a una de las que más me ha gustado. Se trataba de una utilidad para comparar la estructura de dos bases de datos SQL Server, para así de este modo poder realizar correctamente el laborioso trabajo de sincronizar bases de datos de laboratorio con pre-producción, o de pre-producción con producción. Algo que siempre ha sido un tanto *delicado* (aunque desde la aparición de Team System For Database ha mejorado mucho), ya que no siempre se dispone de la infraestructura necesaria para montar un servidor Team System.

Algunas de las herramientas que más me han gustado de esta suite de componentes son:

SQL Compare: Compara y sincroniza bases de datos SQL Server de forma extremadamente sencilla. Poner en producción los últimos cambios nunca ha sido tan fácil... basta con abrir un proyecto, seleccionar las bases de datos, especificar que objetos se desean comparar, y lanzar el analizador. En unos minutos, dependiendo del tamaño de nuestra base de datos tendremos un informe con las diferencias, y las posibilidad de sincronizar los esquemas en el sentido que deseemos. En fin, ¡una joyita que engancha!

SQL Prompt: Un juguetito maravilloso. Que te parecería disponer de Intellisense en tu editor de T-SQL? Esta utilidad hace que enlazar cuatro tablas mediante JOINS deje de ser una cuestión de buena memoria. Hace que te preguntes como demonios lo hacías hasta ahora...

SQL Dependency Tracker: Impactante. No he visto una utilidad mejor para realizar un mapa visual de los objetos y dependencias de una base de datos y colgarlo en la pared. La verdad es que verlo cambiar la disposición de los objetos 'al vuelo' es una delicia.

SQL Refactor: Refactoring en T-SQL? Pues tal y como suena. En este caso una imagen vale más que 1000 palabras:

Sin olvidarnos del resto... SQL Packager nos permite integrar el proceso de instalación de bases e datos en el proyecto de instalación de la aplicación. SQL Doc, documenta el contenido de la base de datos y lo muestra en formato HTML, con esta utilidad ya no hay excusa para no tener las BD bien documentadas y accesibles para todos. SQL Backup nos permite realizar backups hasta 10 veces más rápido que el backup nativo y encriptados mediante 256-bit AES...

En fin, a mi juicio una herramienta de las que vale la pena tener.

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

Cuando de evaluar herramientas se trata

lfranco — Mon, 18 Feb 2008 13:51:48 GMT

Hoy en día, como arquitectos / analistas / desarrolladores de software disponemos de un sinfín de recursos en el mercado. Desde componentes de interfaz de usuario (tanto Windows como Web), librerías de clases que extienden las capacidades del ya poderoso Framework, generadores de código que nos prometen reducir las tareas repetitivas en la construcción de aplicaciones, herramientas para aumentar nuestra productividad, etc.

En muchas ocasiones usar estos recursos adecuadamente puede reportarnos ventajas, como por ejemplo conseguir una interfaz de usuario más atractiva, extender la funcionalidad en nuestra aplicación, reducir el tiempo de desarrollo o simplemente mejorar nuestra organización. Y por otro lado, usarlos incorrectamente puede ser origen de muchos males, desde dependencia de terceras partes, pérdida de control y de performance, hasta agujeros en la seguridad de nuestro código.

Durante años he ido cambiando mi perspectiva sobre el uso de estas herramientas, he tenido temporadas en las que los defendido su uso y otras en las que bajo ningún concepto entraban a formar parte de mis proyectos (supongo que todos pasamos por etapas más o menos puristas :-D), pero creo que como casi todo en esta vida lo mejor es un término medio.

Si conocemos las herramientas que tenemos alrededor y sabemos cuáles son los puntos fuertes y débiles de cada una de ellas, si somos capaces de usarlos correctamente para agregar valor añadido en nuestras aplicaciones (jamás usarlos de forma indiscriminada), y si disponemos de los recursos económicos suficientes para acceder a ellos, puede ser interesante incorporarlos a nuestro banco de herramientas de trabajo.

Por lo tanto es muy importante estar bien informado de lo que nos ofrece el mercado, lo cual no es tarea nada sencilla. Existen cientos de miles de componentes en el mercado, e intentar conocerlos todos puede convertirse en una tarea titánica, capaz de desanimar a más de uno.

Desde mi perspectiva, como MVP tenemos acceso a muchas de estas herramientas gracias al programa de licencias NFR (not for resale) para MVPs, en el que muchos fabricantes nos proporcionan acceso a sus componentes para recibir a cambio feedback por nuestra parte. Mediante este trato quid-pro-quo ambos salimos beneficiados, ya que el colectivo MVP tenemos acceso gratuito a multitud de herramientas, y los fabricantes reciben a cambio dos cosas: Feedback i Publicidad.

Este Feedback es importante, porque como colectivo se nos respeta. Un MVP es un profesional INDEPENDIENTE especialista en tecnología de Microsoft, pero precisamente por ser independientes no nos casamos con nadie (o por lo menos no deberíamos). Que utilizo productos de Microsoft? Pues eso es ni más ni menos porque a día de hoy son los productos que me proporcionan más valor añadido como profesional. Evidentemente, el entorno también cuenta, y si desarrollo software quiero que sea compatible con la mayor plataforma posible, así que también es un factor a tener en cuenta. De este modo, cuando se envía feedback de un producto, ese feedback no está condicionado, y precisamente por eso es valorado.

También reciben a cambio publicidad indirecta, ya que en ocasiones, en los foros o grupos de noticias alguien nos pregunta por algún tipo de componente o nos pide consejo sobre alguna herramienta. De modo que si alguna herramienta de las que hemos probado nos ha dejado buen sabor de boca la recomendamos. En una ocasión un responsable de relaciones públicas de una importante empresa de componentes, me dijo lo mucho que valoraban una opinión o comentario positivo por parte del colectivo MVP. En palabras suyas "Un comentario de un MVP en un foro público es nuestra mejor publicidad".

Esto hace que tenga que ser un poco cuidadoso, no quiero que nadie piense que cuando recomiendo algo lo hago basado en que me han regalado un producto, o me han mandado un jamón por navidad :-P

No se trata de eso, es algo tan simple como que he podido acceder a probar esta herramienta y me ha gustado. Y por este motivo la recomendaré a quién me lo pregunte. Y que conste que mi opinión es algo totalmente personal, basado en mi propia experiencia... Jamás voy a recomendar una herramienta que no haya probado personalmente y que no me haya gustado.

Aclarado esto, en los próximos días voy a escribir una serie de posts en los que voy a ir comentando una serie de herramientas. No van a ser todas las que he probado puesto que no terminaría nunca, pero si voy a ir comentando aquellas que me han dejado un mejor sabor de boca.

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

gsBuscarTexto - Utilidad para buscar ficheros bajo Windows Vista

lfranco — Fri, 08 Feb 2008 10:02:31 GMT

gsBuscarTexto v2.0.5.1

El colega Guille acaba de publicar una nueva versión de su utilidad para buscar archivos en carpetas "gsBuscarTexto". El motivo es que como resulta que el agüelo ya tiene una edad, esto de buscar cosas en Windows Vista se le hacía un poco cuesta arriba :-P, así que ni corto ni perezoso un día se creó esta estupenda utilidad, que permite lanzar búsquedas desde el explorador mediante el menú contextual.

La verdad es que tiene muy buena pinta, y el feedback hasta ahora dice que funciona incluso mejor que la original...

Resumen de las novedades de la utilidad

Como te dije antes, la utilidad tiene muchas cosas nuevas, pero en vez de explicártelas todas, te relaciono la mayoría de ellas (digo la mayoría, porque seguro que se me habrá escapado alguna):

-Se pueden indicar directorios desde la línea de comandos o arrastrándolos al acceso directo del programa
-Añado acerca de
-Se comprueba si se ejecuta como administrador
-Opciones de la línea de comandos.
- Se permiten:
  /h, Muestra la ventana de la ayuda
  /usardir, Al soltar directorios, si se mantiene lo que ya hubiera en el combo Directorios
  /nobuscar, Desactiva la opción de buscar (predeterminado con el menú contextual)
  /buscar, Activa la opción de buscar texto
  /nofecha, Desactiva la opción de buscar por fecha (predeterminado con el menú contextual)
  /fecha, Activa la opción de buscar por fecha
  /sub, Activa la opción de buscar en subdirectorios (predeterminado con el menú contextual)
  /nosub, Desactiva la opción de buscar en subdirectorios
  /noerror, Activa la opción de ignorar errores (predeterminado con el menú contextual)
  /error, Desactiva la opción de ignorar errores
  /reg+, Registra el programa en el menú contextual del explorador de Windows
  /reg- Quita el programa del menú contextual del explorador de Windows
-Añadir una opción al menú contextual del explorador de Windows
-Ventana de configuración para esta nueva funcionalidad
-Cambio a aplicación de una instancia, para soportar varios directorios desde el menú contextual
-Ayuda de los comandos que se pueden usar
-Al buscar textos, se puede buscar línea a línea o en el fichero completo
-Varios cambios menores en los totales mostrados
-Opción para mostrar los ficheros hallados (será más lento)
Opción en el botón de buscar
-En configuración poder restaurar tamaño ventana principal
-En configuración opciones para el directorio de la configuración
-Guarda los datos de configuración en los documentos del usuario (Cada vez que se cambia de versión, se resetean...)
-Se puede indicar el directorio en el que se guardará

Así que a probarla!

:-D

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