abril 2010 – Conecto luego existo

Automatizar documentos Office 2010 con datos de SharePoint 2010

Como Office 2010 y SharePoint 2010 ya están al caer, me apetecía crear una aplicación que nos permita trabajar con ambas plataformas, y que por supuesto tenga alguna utilidad interesante. En el artículo de hoy vamos a ver como podemos automatizar nuestros documentos de Word 2010 con los datos que obtenemos de una lista de contactos de SharePoint 2010. Esto es muy útil para informes que siguen una misma estructura como puede ser la invitación a un evento, que es el caso que vamos a ver a continuación.

Para ello, partiendo de un documento inteligente (Smart Document), vamos a utilizar la potencia que nos ofrecen las herramientas VSTO (Visual Studio Tools for Office) para la creación de aplicaciones de negocio para Office. Estas ya vienen integradas en VS 2010, y nos permiten crear aplicaciones tanto para la versión 2007 como para la versión 2010 de Office.

Abrimos VS 2010 y creamos un proyecto de tipo Word Document2010, que en nuestro caso llamaremos InvitacionCES.

Una vez creado el documento sobre el que vamos a trabajar, lo primero que hacemos es añadir un elemento de tipo Action Pane Control, que utilizaremos como navegador de nuestros contactos. Para ello hacemos clic con el botón derecho sobre nuestro proyecto y seleccionamos Add > New Item> ActionsPaneControl que llamaremos NavegadorContactos.

Dentro de nuestro panel de acciones, añadiremos los controles que vamos a utilizar para mostrar las propiedades de los elementos de la lista, teniendo en cuenta cuales son las propiedades que queremos mostrar. Viendo los elementos que debemos rellenar en nuestro documento, nuestro panel de acciones debe tener un aspecto similar a este:

Hasta este punto hemos diseñado nuestro panel de acciones, pero todavía nos falta añadirlo al documento Word para que este se visualice, y darle la funcionalidad deseada. Para lo primero, es necesario crear una instancia del control en el archivo ThisDocument.cs de nuestra aplicación:

NavegadorContactos Contactos = new NavegadorContactos();

Y hacer que dicho control se añada a la aplicación cuando arrancamos Word. Esto último se hace a través del evento ThisDocument_Startup

private void ThisDocument_Startup(object sender, System.EventArgs e)
        {
            this.ActionsPane.Controls.Add(Contactos);
        }

A continuación vamos a darle funcionalidad al “navegador de contactos”. En nuestro caso, vamos a implementar un servicio web que nos permita conectar la aplicación cliente de Office con nuestro sitio SharePoint: http://sharepoint2010:200 y que rellene los controles de nuestro panel con los datos de la lista de contactos. Para añadir un servicio web a la misma, pinchamos con el botón derecho sobre Referencias > Agregar referencia de servicio en el explorador de soluciones. Dentro de todos los servicios disponibles en la máquina local, especificamos la URL del servicio al que nos queremos conectar, que en nuestro caso es http://localhost:200/_vti_bin/Lists.asmx (ya que Contactos es un tipo de Lista), y le damos el nombre de ContactosSP. De esta manera ya podemos usar este servicio Web en nuestro proyecto.

Ahora que ya hemos creado nuestro servicio web para conectarnos a la aplicación SharePoint, vamos a implementar el código necesario para que los controles realicen su función correctamente. Para ello vamos al archivo NavegadorContactos.cs, y añadimos dos clases más aparte de la existente (NavegadorContactos) una que se encargará de construir los Items que forman nuestro ComboBox:

Elementos del combobox

public class Item
    {
        public string Name;
 
        public Item(string name)
        {
            Name = name;
 
        }
        public override string ToString()
        {
            // Genera el texto mostrado en el ComboBox 
            return Name;
        }
    }

Y otra que se encargará de construir un objeto Contacto con los siguientes atributos:

Elemento Contacto

public class Contacto
    {
        public string Name;
        public string LastName;
        public string City;
        public string ZipCode;
        public string Country;
        public string Email;
        public string Telephone;
        public string Company;
 
        public Contacto(string name, string lastname, string city, string zipcode, string country, string email, string telephone, string company)
        {
            Name = name;
            LastName = lastname;
            City = city;
            ZipCode = zipcode;
            Country = country;
            Email = email;
            Telephone = telephone;
            Company = company;
        }
 
    }

A continuación dentro de la clase NavegadorContactos, inicializamos las variables que vamos a utilizar y que son necesarias para ir leyendo las propiedad de los elementos de la lista en SharePoint, ya que dicha información la obtenemos a partir de un documento XML

Inicializacion variables

XmlNode listNode, contactFN, contactLN, contactEM, contactMP, contactWC, contactZC, contactCR, contactCN;
        XmlAttributeCollection nodeAttribs;
        XmlDocument xmlDoc;
        XmlNode ndViewFields;
        XmlNode ndListItems;
        Contacto cont;
        List<Contacto> mContact = new List<Contacto>();

Creamos un método llamado BuscarContactos que es el que se encargará de conectarse al servicio web creado y obtener los datos almacenados en nuestra lista de Contactos. Constará del siguiente código:

Buscar Contactos

public void BuscarContactos()
        {
 
            ContactosSP.Lists contactosService = new InvitacionCES.ContactosSP.Lists();
 
            // Creamos las credenciales que nos permiten conectarnos a
            // SharePoint y las asignamos al servicio
 
            System.Net.NetworkCredential myCred = new System.Net.NetworkCredential(«Administrador», «AdmSP2010»);
 
            contactosService.Credentials = myCred;
 
            // Recuperamos 
 
            listNode = contactosService.GetList(«Contactos»);
 
            // Creamos las estructuras XML necesarias para volcar nuestra información
 
            xmlDoc = new System.Xml.XmlDocument();
 
            ndViewFields = xmlDoc.CreateNode(XmlNodeType.Element, «ViewFields», «»);
 
 
            // Indicamos los campos que queremos que nos muestre, es decir la vista
 
            ndViewFields.InnerXml = «<FieldRef Name=’LinkTitle’/><FieldRef Name=’FirstName’/><FieldRef Name=’Email’/><FieldRef Name=’CellPhone’/><FieldRef Name=’WorkCity’/><FieldRef Name=’WorkZip’/><FieldRef Name=’Company’/><FieldRef Name=’WorkCountry’/>»;
 
 
            try
            {
                // Indicamos que lista queremos que lea y la vista de la misma
 
                ndListItems = contactosService.GetListItems(«Contactos», null, null, ndViewFields, null, null, null);
 
                // Procesamos cada elemento recuperado buscando el título
 
                foreach (XmlNode node in ndListItems.ChildNodes)
                {
 
                    // El contenido va en los subnodos que nos devuelve SharePoint
 
                    foreach (XmlNode subnode in node.ChildNodes)
                    {
 
                        // Buscamos valores de los atributos del nodo
 
                        nodeAttribs = subnode.Attributes;
 
                        if (nodeAttribs != null)
                        {
                            // Obtenemos los valores de los atributos de los subnodos
                            contactFN = nodeAttribs.GetNamedItem(«ows_FirstName»);
                            contactLN = nodeAttribs.GetNamedItem(«ows_LinkTitle»);
                            contactEM = nodeAttribs.GetNamedItem(«ows_Email»);
                            contactMP = nodeAttribs.GetNamedItem(«ows_CellPhone»);
                            contactWC = nodeAttribs.GetNamedItem(«ows_WorkCity»);
                            contactZC = nodeAttribs.GetNamedItem(«ows_WorkZip»);
                            contactCR = nodeAttribs.GetNamedItem(«ows_WorkCountry»);
                            contactCN = nodeAttribs.GetNamedItem(«ows_Company»);
                            //Creamos nuestros contactos y los añadimos a la lista de contactos
                            cont = new Contacto(contactFN.Value, contactLN.Value, contactWC.Value, contactZC.Value, contactCR.Value, contactEM.Value, contactMP.Value, contactCN.Value);
                            mContact.Add(cont);
                            //Anadimos los apellidos de nuestros contactos al comboBox
                            cb_Contactos.Items.Add(new Item(cont.LastName));
 
                        }
 
 
                    };
 
                };
 
            }
            // Definimos una excepción de conexión al servicio web
 
            catch (System.Web.Services.Protocols.SoapException ex)
            {
 
                MessageBox.Show(«Message:n» + ex.Message + «nDetail:n» + ex.Detail.InnerText + «nStackTrace:n» + ex.StackTrace);
 
            }
 
        }

Llamaremos a dicho método cuando se haga clic sobre el botón Conectar. Mediante este método se van a cargar en nuestro ComboBox los apellidos de los distintos contactos que tengamos almacenados en nuestra lista de Contactos.

Conectar

private void but_Conectar_Click(object sender, EventArgs e)
        {
            BuscarContactos();
            //Deja no visible el control conectar
            but_Conectar.Visible = false;
        }

Y por último definimos el evento, que hará que al seleccionar en cada uno de elementos del combobox se nos carguen el resto de valores de nuestro contacto (nombre, email, teléfono…) tanto en los controles del navegador como en los controles del documento.

Carga de contactos

private void cb_Contactos_SelectedIndexChanged(object sender, EventArgs e)
        {
            for (int i = 0; i <= cb_Contactos.SelectedIndex; i++)
            {
                Globals.ThisDocument.richTextContentControl1.Text = mContact[i].LastName;
 
                tb_Email.Text = mContact[i].Email;//Rellenamos el cuadro de texto Email del navegador
                Globals.ThisDocument.richTextContentControl2.Text = tb_Email.Text;//Rellenamos el campo Email del documento
 
                tb_City.Text = mContact[i].City;//Rellenamos el cuadro de texto Ciudad del navegador
                Globals.ThisDocument.richTextContentControl3.Text = tb_City.Text;//Rellenamos el campo Ciudad del documento
 
                tb_ZipCode.Text = mContact[i].ZipCode;//Rellenamos el cuadro de texto Codigo Postal del navegador
                Globals.ThisDocument.richTextContentControl4.Text = tb_ZipCode.Text;//Rellenamos el Codigo Postal del documento
 
                tb_Country.Text = mContact[i].Country;//Rellenamos el cuadro de texto Pais del navegador
                Globals.ThisDocument.richTextContentControl6.Text = tb_Country.Text;//Rellenamos el campo Pais del documento
 
                tb_Telephone.Text = mContact[i].Telephone;//Rellenamos el cuadro de texto Telefono del navegador
                Globals.ThisDocument.richTextContentControl5.Text = tb_Telephone.Text;//Rellenamos el campo Telefono del documento
 
                tb_Company.Text = mContact[i].Company;
                Globals.ThisDocument.richTextContentControl7.Text = tb_Company.Text;
 
                tb_Name.Text = mContact[i].Name; //Rellenamos el cuadro de texto Nombre del navegador
                Globals.ThisDocument.richTextContentControl8.Text = tb_Name.Text;//Rellenamos el campo Nombre del documento
            }
 
 
        }

Para ver que todo funciona correctamente, compilamos (F5) y observamos que el resultado es el siguiente:

Como se puede ver, es posible navegar por los distintos elementos mediante el combobox, de forma que podemos rellenar nuestros documentos de forma automática y sin el menor esfuerzo….para el usuario.

Además si probamos a añadir más contactos en nuestra lista de SharePoint veremos como estos se actualizan dinámicamente al conectarnos al servicio web desde nuestro navegador de contactos.

Espero que os resulte interesante.

Descargar el proyecto aquí

Diferencias en la programación de ASP.NET MVC con VS 2008 y VS 2010

Trabajando con las últimas versiones de Visual Studio, 2008 en casa y 2010 en el trabajo, me he encontrado con algunas diferencias entre ambas. En concreto he visto dos pequeñas “cositas” a tener en cuenta.

Por un lado, tanto si programamos con VS 2008 como 2010, al crear un nuevo controlador existe la opción de añadir una serie de métodos básicos (Create, Update, Details) que facilitan la interactuación con nuestro modelo de datos. Sin embargo, mientras que en la versión 2008 podemos implementar el método Delete de forma automática, en VS 2010 no tenemos esta opción, como se puede observar en las siguientes imágenes:

VS 2008 VS 2010

De forma que cuando vamos a crear una vista en VS 2008, podemos aplicar un tipo de contenido de vista llamado Delete, que nos crea el formulario básico para la eliminación de elementos. Mientras que en 2010 tendremos que crear esta vista a mano.

VS 2008

Por otro lado si seguimos los tutoriales expuestos en la página http://www.asp.net/mvc/, donde encontramos numerosos recursos para el desarrollo de aplicaciones ASP.NET MVC, vemos que estos están preparados para trabajar con VS 2008. Por ejemplo, dentro del método Edit se utiliza la función ApplyPropertyChanges para aplicar las modificaciones sobre las propiedades de los elementos de nuestro modelo de datos:

mbook.ApplyPropertyChanges(bookOriginal.EntityKey.EntitySetName,bookToEdit);

Mientras que en VS 2010 esta función está obsoleta y es necesario implementar la función ApplyCurrentValues quedando el código de la siguiente manera:

mbook.ApplyCurrentValues(bookOriginal.EntityKey.EntitySetName, bookToEdit);

Según vaya encontrado más diferencias o aspectos a tener en cuenta os los iré contando.

Modificar elementos del modelo de datos en ASP.NET MVC

En mi post anterior vimos como se podía mostrar los elementos de una base de datos de manera sencilla, pero todavía no éramos capaces de interactuar con ella. Así que vamos a ir viendo como podemos conseguir trabajar con nuestro modelo de datos, implementando algunas acciones específicas mediante un controlador y una serie de vistas.

Para ello vamos a partir del proyecto MvcBookApp, que cree en el post anterior y vamos a ir dotándolo de las funcionalidades Crear, Editar y Mostrar detalles, que son las acciones que se nos añadieron al controlador HomeController al crearlo:

Inicialmente añadiremos la referencia a

using MvcBookApp.Models

de forma que podamos trabajar más cómodamente con los objetos definidos en nuestro modelo. A continuación comenzaremos por implementar la opción Crear, que nos permitirá crear nuevos elementos en nuestra base de datos. Para ello vamos al archivo HomeController.cs y dentro del método Create():

Hacemos clic con el botón derecho y añadimos una vista
Dejamos el nombre que toma por defecto (Create)
Verificamos que está seleccionado el chekbox “Create a strongly-typed view”
Seleccionamos el valor MvcBookApp.Models.Book dentro de la lista desplegable View data class
Seleccionamos el valor Create dentro de la lista desplegable View content
Hacemos clic en el botón Add para añadir la nueva vista.

Como podemos observar el controlador contiene dos métodos denominados Create(). El primero se encarga de mostrar el formulario HTML para crear un nuevo registro. El segundo método se llama cuando se ejecuta el formulario HTML en el servidor, y este contiene la lógica para la inserción de un nuevo libro en la base de datos Book.

Como no nos interesa que el usuario cree el valor del bookID, sino que su actualización sea dinámica, vamos a quitarlo de la vista. Para ello eliminamos el siguiente código:

<div class="editor-label">
<%= Html.LabelFor(model => model.bookID) %>
</div>
<div class="editor-field">
<%= Html.TextBoxFor(model => model.bookID) %>
<%= Html.ValidationMessageFor(model => model.bookID) %>
</div>

Por último vamos a establecer el código que se ejecutará como resultado de la acción Create, dentro de las acciones del controlador:

// POST: /Home/Create
[HttpPost]
public ActionResult Create(Book bookC)
{
try
{
// TODO: Add insert logic here
if (!ModelState.IsValid)
{
return View();
}
mbook.AddToBooks(bookC);
mbook.SaveChanges();
return RedirectToAction("Index");
}
catch
{
return View();
}
}

De esta forma si compilamos podemos ver como al seleccionar el vinculo Create new, nos aparece un formulario para introducir un nuevo elemento,permitiéndonos crear nuevos elementos:

A continuación vamos a implementar la funcionalidad de Editar. Para ello vamos a seguir los mismos pasos que antes, y dentro del archivo HomeController.cs, en el método Edit:

Hacemos clic con el botón derecho y añadimos una vista
Dejamos el nombre que toma por defecto (Edit)
Verificamos que está seleccionado el chekbox “Create a strongly-typed view”
Seleccionamos el valor MvcBookApp.Models.Book dentro de la lista desplegable View data class
Seleccionamos el valor Edit dentro de la lista desplegable View content
Hacemos clic en el botón Add para añadir la nueva vista.

Por último establecemos el código que se ejecutará como resultado de la acción Edit, y que será el siguiente:

// GET: /Home/Edit/5
public ActionResult Edit(int id)
{
var bookE = (from m in mbook.Books
where m.bookID == id
select m).First();
return View(bookE);
}
//
// POST: /Home/Edit/5
[HttpPost]
public ActionResult Edit(Book bookE)
{
try
{
var bookO = (from m in mbook.Books
where m.bookID == bookE.bookID
select m).First();
if (!ModelState.IsValid)
return View(bookO);
mbook.ApplyCurrentValues(bookO.EntityKey.EntitySetName, bookE);
mbook.SaveChanges();
return RedirectToAction("Index");
}
catch
{
return View();
}
}

Si compilamos podemos ver como al seleccionar el vinculo Edit, nos aparece un formulario que nos permite modificar el elemento seleccionado de nuestra lista.

Para terminar vamos a implementar la funcionalidad que nos permita mostrar los detalles de un elemento. Para ello vamos a seguir los mismos pasos que antes, y dentro del archivo HomeController.cs, en el método Details:

Hacemos clic con el botón derecho y añadimos una vista
Dejamos el nombre que toma por defecto (Details)
Verificamos que está seleccionado el chekbox “Create a strongly-typed view”
Seleccionamos el valor MvcBookApp.Models.Book dentro de la lista desplegable View data class
Seleccionamos el valor Details dentro de la lista desplegable View content
Hacemos clic en el botón Add para añadir la nueva vista.

Por último implementaremos la funcionalidad para mostrar, en formato de detalles, los elementos de nuestra base de datos mediante el siguiente código:

public ActionResult Details(int id)
{
Book book = mbook.Books.FirstOrDefault(elemento => elemento.bookID == id);
return View(book);
}

Si compilamos podemos ver como al seleccionar el vinculo Details, obtenemos los detalles del elemento seleccionado.

Para personalizar un poco la aplicación, he modificado alguna de las vistas para que aparezcan los títulos en negrita, y también he eliminado el campo del ID porque no me interesa que se vea en algunas ocasiones. De esta forma ya tendríamos nuestra aplicación perfectamente funcionando, y le podríamos añadir nuevas funcionalidades como, por ejemplo, la opción Delete.

Mostrar datos de un Modelo en ASP.NET MVC

Para comenzar mi andadura aquí en Geeks, y también con esta plataforma, voy a escribir acerca de como crear un modelo de datos en nuestra aplicación ASP. NET MVC y sobre como podemos mostrar los datos que extraemos del mismo de forma sencilla.

Lo primero que vamos a hacer es crear nuestra base de datos, donde almacenaremos la información que queremos mostrar en la página, que en nuestro caso serán un conjunto de libros. Hacemos clic con el botón derecho sobre App_Data, y seleccionamos Add > New Item, de tipo SQL Server DataBase, y le damos el nombre de BooksDB.mdf.

*Por defecto todos los elementos de tipo de datos que vayamos a utilizar en nuestra aplicación web, se deben almacenar en la carpeta App_Data. Si no lo hacemos así, la propia aplicación se encargará de preguntárnoslo.

Una vez creada nuestra base de datos (BookDB.mdf) , hacemos doble clic sobre la misma y se nos desplegará en el Explorador de Servidores. Dentro de Books.mdf, hacemos clic con el botón derecho sobre Tables , y seleccionamos Add > New Table.

Dentro de la tabla, vamos a añadir los campos específicos que queremos que tengan cada uno de los elementos de nuestra tabla, que en nuestro caso son: bookID (int), Titulo (nchar), Autor (nchar), y deseleccionamos la opción “Allow Nulls”, ya que nuestros elementos deben contener las tres propiedades definidas, y no se pueden quedar ninguno en blanco.

A continuación, establecemos como Primary Key la columna bookID de nuestra tabla, y ponemos su propiedad IsIdentity a True .

Finalmente guardamos nuestra tabla dándole el nombre de Books.

Una vez creada la tabla, vamos a introducir algunos elementos a la misma. Para ello, hacemos clic con el botón derecho sobre Books, seleccionamos Show Table Data, y añadimos los libros que queremos mostrar inicialmente.

A continuación es necesario crea un modelo que nos permita conectar nuestra aplicación con la base de datos, para ello vamos a la carpeta Models > Add > New Item. Seleccionamos un elemento de tipo ADO.NET Entity Data Model que llamaremos BookModel, y vamos siguiendo el Wizard, tal y como se puede observar en las siguientes imágenes.

De esta forma ya tenemos creado nuestro modelo, que tendrá el siguiente aspecto, y al que cambiaremos el nombre de Books por Book.

Una vez creado el modelo, vamos a crear la vista y el controlador que nos permitan interactuar con él. Para ello, primero vamos a la carpeta Controllers, eliminamos el archivo HomeController que se nos ha creado por defecto y añadimos otro llamado igual, haciendo clic con el botón derecho mediante Add > Controller. Para este, seleccionaremos la opción de añadir los métodos Create, Update y Details, de forma que no sólo podamos ver los elementos de nuestro modelo, sino que también podamos editarlos o crear nuevos, como veremos en el próximo articulo.

Si accedemos al código del controlador, podemos ver que hay varios métodos de tipo ActionResult. Estos son los que se encargan de lanzar las acciones especificas que se deben realizar en cada vista. En nuestro caso, queremos asociar la acción Index con una vista que nos permita mostrar en la página principal una lista con todos los elementos de nuestro modelo. Para ello eliminamos previamente, la vista Index, que se encuentra dentro de las carpetas Views > Home, y creamos una nueva vista haciendo clic con el botón derecho en Index() dentro del archivo HomeController.cs, tal y como se ve en la imagen.

Al crear una nueva vista debemos definir una serie de parámetros, en función de lo que queremos mostrar y cómo. Dejamos el nombre que toma por defecto (Index), y seleccionamos la opción Create a strongly-typed view. Como View Data Class, escogemos MvcBookApp.Models.Book. *Si esta opción no nos aparece inicialmente, es necesario depurar la aplicación y volver a repetir este último paso.

Y como View content, debemos seleccionar List, ya que queremos que dicha vista nos muestre nuestro elementos en formato lista. El resto de parámetros los dejamos tal y como están, y pulsamos Add. Como vemos, la vista que se nos crea es una página .aspx, por lo que podemos modificar la interfaz de la misma a través de este archivo, bien en modo diseño o de código.

Por último volvemos a HomeController.cs, donde crearemos una instancia a nuestra entidad del modelo de datos:

MvcBookApp.Models.BooksDBEntities mbook = new Models.BooksDBEntities();

Y modificaremos el resultado de la acción de Index, para que se muestre nuestra entidad de datos a través de una lista. El código de la misma será el siguiente:

public ActionResult Index()
        {
            return View(mbook.Books.ToList());
        }

Si compilamos nuestra aplicación (F5) veremos que nos aparece la lista con nuestro libros, pero no podemos interactuar con ella, ya que no hemos definido ni las vistas, ni las acciones del controlador que nos lo permitan. Esto lo veremos en el siguiente Post 😉

¡¡Así que seguid atentos!!