Inserción de formularios mediante acceso anónimo

Guardar un formulario InfoPath en una librería no tiene mayor problema que el de configurar nuestro Submit indicándole la librería donde vamos a insertarlo. Este problema se agrava cuando lo que tenemos son formularios accesibles anónimamente, ya que SharePoint no nos dejará guardarlos.

Podemos habilitar las Libraries para que el usuario anónimo pueda ver elementos, pero este tipo de usuario no tendrá más permisos. Para solventar esto lo que necesitamos es una estructura puente, con permisos suficientes, que nos guarde el formulario en la librería correspondiente. Esta estructura puente será un Web Service. El Web Service contendrá un único método web:

[WebMethod]
public void SubmitToFormLibrary(string siteName, string webName, string formLibraryName, string formName, string formXml)
{
formName = formName.TrimEnd('.');
SPSite site = new SPSite(siteName + "/");
SPWeb web = site.OpenWeb(webName);
SPFolder folder = web.GetFolder(formLibraryName);
foreach (SPFile file in folder.Files)
{
if (file.Name.Replace(".xml", "") == formName)
throw new Exception("El fichero ya existe.");
}
folder.Files.Add(formName + ".xml", UnicodeEncoding.UTF8.GetBytes(formXml));
}

al cual le pasaré una serie de parámetros que me determinarán el lugar donde irá a parar el formulario:
siteName: Nombre del site
webName: Nombre del web
formLibraryName: Nombre de la librería
formName: Nombre del formulario
formXml: Contenido del formulario

En el web.config de nuestro servicio web añadiremos el siguiente código:

En “identity” pondremos un usuario que tenga los permisos suficientes para poder grabar el formulario en la librería. Una vez configurado el servicio web podemos probarlo para ver que inserta correctamente:

Pinchamos en nuestro servicio web y veremos los parámetros que requiere el mismo.


Rellenamos los datos y probamos que lo inserta bien:

Ya tenemos validado que el web service funciona. Ahora pasamos a crearnos un formulario y configuraremos el Submit del mismo.

Antes de comenzar hay que tener en cuenta que necesitamos una Seccion, que estará oculta y que contendrá la información de los diferentes parámetros que se le pasarán al web service. El resto del formulario se creará como nosotros queramos.

Nos creamos el botón de ‘Submit’ y lo configuramos para que envíe datos al web service:

Añadimos una conexión de Submit:

Seleccionamos nuestro método web y asignamos los campos que tenemos del formulario a los diferentes parámetros del método web:

La única excepción será el último parámetro, que es el contenido del formulario. Para este campo seleccionaremos la opción de “Entire Form”:

Y ya tenemos nuestro formulario configurado para que haga el Submit mediante un web service. Ahora sólo nos faltará probarlo y comprobar en la librería que se ha grabado todo correctamente:

Enviamos:

Comprobamos la librería:

Saludos,
Juan Alcalá

InfoPath 2007 - Añadir filas a una "Repeating Table" mediante codigo

Es posible que alguna vez necesitemos cargar los datos en una tabla de forma dinámica, en función de una serie de parámetros que introduzcamos previamente. Llegado ese momento este post os puede ayudar.

La estructura de nuestra tabla tendrá, más o menos, la siguiente composición de controles:




el código que necesitaremos es el siguiente. Os lo pongo en C# y en VB:

C#

string myNamespace = NamespaceManager.LookupNamespace("my");
using (XmlWriter writer = MainDataSource.CreateNavigator().SelectSingleNode("/my:myFields/my:group1", NamespaceManager).AppendChild())
{
   writer.WriteStartElement("group2", myNamespace);
   writer.WriteElementString("field1", myNamespace, "Cell 1");
   writer.WriteElementString("field2", myNamespace, "Cell 2");
   writer.WriteElementString("field3", myNamespace, "Cell 3");
   writer.WriteEndElement();
   writer.Close();
}

VB

Dim myNamespace As String = NamespaceManager.LookupNamespace("my")
Using writer As XmlWriter = MainDataSource.CreateNavigator().SelectSingleNode( _
"/my:myFields/my:group1", NamespaceManager).AppendChild()
   writer.WriteStartElement("group2", myNamespace)
   writer.WriteElementString("field1", myNamespace, "Cell 1")
   writer.WriteElementString("field2", myNamespace, "Cell 2")
   writer.WriteElementString("field3", myNamespace, "Cell 3")
   writer.WriteEndElement()
   writer.Close()
End Using

Servicios Web en Sharepoint

Estos son los Servicios Web de los que podemos disponer en Sharepoint y que nos pueden ahorrar mucho trabajo a la hora de programar diferentes funcionalidades para nuestro SharePoint:

Administration Service http:///_vti_adm/admin.asmx
Alerts Service http:///_vti_bin/alerts.asmx>
Document Workspace Service http:///_vti_bin/dws.asmx
Forms Service http:///_vti_bin/forms.asmx
Imaging Service http:///_vti_bin/imaging.asmx
List Data Retrieval Service http://_/_vti_bin/dspsts.asmx
Lists Service http:///_vti_bin/lists.asmx
Meetings Service http://_vti_bin/meetings.asmx
Permissions Service http://_/_vti_bin/permissions.asmx
Site Data Service http:///_vti_bin/sitedata.asmx
Site Service http:///_vti_bin/sites.asmx
Users and Groups Service http://_/_vti_bin/usergroup.asmx
Versions Service http:///_vti_bin/versions.asmx
Views Service http:///_vti_bin/views.asmx
Web Part Pages Service http:///_vti_bin/webpartpages.asmx
Webs Service http:///_vti_bin/webs.asmx

Submit en InfoPath 2007 (por codigo)

Si queremos añadir funcionalidad a nuestro Submit en InfoPath deberemos realizar toda esta funcionalidad con codigo por detrás. Para ello lo primero que hacemos es realziar el submit y acto seguido editamos el item y modificamos los campos que queramos. Esto nos puede servir para insertar columnas adicionales o simplemente actualizar columnas existentes con nuevos valores.

La funcion sería algo así:

public void FormEvents_Submit(object sender, SubmitEventArgs e)
{
// Declaramos todas las variables que nos van a hacer falta ...
string sitePath = "http:// ... ruta del site";
string webName = "PuertaPuerta";
string listaName = "Formularios";
string codigoPath = "/my:assetTracking/my:field18";
string revisoresName = "Revisor";
string zonaName = "Zona";
StreamWriter sw = null;
try
{
FileStream file = new FileStream("C:\ ruta del log de errores donde queremos registrarlos", FileMode.Append,FileAccess.Write);
sw = new StreamWriter(file);
}
catch(Exception ex) { }
// Get a reference to the submit data connection
FileSubmitConnection fc = (FileSubmitConnection)this.DataConnections["Submit1"];
try
{
fc.Execute();
System.Threading.Thread.Sleep(2000);
// Insertamos los usuarios que pueden ver ese documento ...
// El documento está insertado. Ahora lo que tenemos que hacer es actualizar el item
SPSite site = new SPSite();
SPWeb web = site.OpenWeb(webName);
web.AllowUnsafeUpdates = true;
SPList lista = web.Lists[listaName];
SPListItem listItem;
string codigo = CreateNavigator().SelectSingleNode(codigoPath, NamespaceManager).InnerXml;
for (int i = 0; i <= lista.ItemCount - 1; i++)
// Buscamos el item que nos hace falta. Podemos usar tambien el SPQuery
{
// Realizamos la actualizacion que deseemos en el item
// Actualizamos el item...
listItem.Update();
}
}
// Efectuamos el Submit para que el formulario se cierre.
e.CancelableArgs.Cancel = false;
}
catch (Exception ex)
{
sw.WriteLine(ex.Message + ": " + System.DateTime.Now.ToString());
e.CancelableArgs.Cancel = true;
}
finally
{
sw.Close();
}

Borrado de ListItems desde InfoPath

Formularios.Lists ListsService = new Formularios.Lists();
ListsService.Url = "[Ruta Site]/_vti_bin/lists.asmx";
ListsService.Credentials = new NetworkCredential(user, pass, dominio);

// Recorremos la lista para encontrar el item a cambiar ...
Microsoft.SharePoint.SPSite sps = new Microsoft.SharePoint.SPSite("[Ruta Site]");
Microsoft.SharePoint.SPWeb spw = sps.OpenWeb([Nombre Site]);
Microsoft.SharePoint.SPList spl = spw.Lists[lista];


// Borraremos el item correspondiente de la lista de Direcciones ...
// Creamos un XML con los datos que vamos a actualizar ...
XmlDocument doc = new XmlDocument();
XmlElement borrar = doc.CreateElement("Batch");
borrar.SetAttribute("OnError", "Continue");

// Creamos un metodo por cada linea que vamos a actualizar ...
XmlElement MetodoBorrar = doc.CreateElement("Method");
MetodoBorrar.SetAttribute("ID", "1");
MetodoBorrar.SetAttribute("Cmd", "Delete");
// Si queremos actualizar un item pondremos "Update". Si queremos insertar una nuevo pondremos "New"
borrar.AppendChild(MetodoBorrar);

// Actualizamos una linea basandonos en su ID interno ...
XmlElement MetodoBorrar1 = doc.CreateElement("Field");
MetodoBorrar1.SetAttribute("Name", "ID"); // que registro actualizamos
MetodoBorrar1.InnerText = id; // Valor de ese registro

MetodoBorrar.AppendChild(MetodoBorrar1);

// Llamamos al servicio Web que borrará el item
XmlNode Result = ListsService.UpdateListItems([Lista sobre la que queremos trabajar], borrar);

ListsService.Dispose();

Formularios InfoPath con SharePoint (3 de 3)

Publicación de nuestro formulario en nuestra librería

Bueno, llegados a este punto ya tenemos nuestra libreria creada (FormulariosInfoPath) y nuestro formulario creado. Necesitamos poder vincularlos y para ello utilizaremos el asistente de publicación que lleva el InfoPath:

Lo primero que nos solicitará es que lo guardemos en algun lugar si no lo habiamos guardado previamente. Seleccionaremos una carpeta y después nos mostrará un asistente que nos dejará 4 opciones:

1.- publicar en un sitio de Sharepoint (esta será la opción que seleccionaremos)
2.- publicar a una lista de mails (si nos interesa que este formulario se envía por correo)
3.- publicar a una dirección de red (esta opción se escoge si nuestro formulario requiere revision por parte de los administradores antes de ser subido al SharePoint. Cuando implementemos formularios más complejos mediente Visual Studio veremos que la unica forma de poder publicarlos será esa)
4.- publicar mediante un instalable.

Dejaremos la primera selección marcada y le daremos a "Siguiente".
En la siguiente ventana del asistente tendremos que ponerle la ruta de nuestro 'Site' que habiamos llamado 'Formularios'. Introducimos la ruta y le damos a 'Siguiente'.

Si la ruta la ha encontrado nos pedirá donde queremos publicar nuestro formulario. Nos deja la opcion de publicarlo en una única libreria, en varias, o con validacion previa del adminitrador. De momento vamos a publicar nuestro formulario en la libreria que tenemos creada:

NOTA: Una opcion interesante es el checkbox de arriba, que si lo seleccionamos permitirá que nuestro formulario sea visible a través de la web, sin necesidad de que el cliente deba tener instalada la aplicación para poder ver el formulario. Marcaremos esta opción.

Pulsamos "Siguiente" y nos aparecerá la libreria que habiamos creado previamente. Como habreis apreciado nos deja la opcion de crearnos una libreria, por lo que posteriormente podremos saltarnos el paso de creación de la form library desde SharePoint y crearla aqui directamente.

Seleccionamos nuestra libreria FormulariosInfoPath y pulsamos "Siguiente" y seguidamente a "Publicar".
Una vez publicada podremos irnos a nuestra libreria y abrir nuestra plantilla de formulario



Si todo ha ido bien se nos abrirá, pero veremos que se nos abre en el cliente InfoPath. Eso es porque lo hemos publicado para verse en web pero no lo hemos habilitado. Para habilitarlo tendremos que ir las Settings de nuestra libreria:


Marcaremos "Advanced Settings" --> "Display as a Web page".
Aceptaremos los cambios y volveremos a abrir nuestro informe. Ahora se nos abrirá en el navegador.

Espero que este curso sirva un poco como iniciación a InfoPath. En proximos posts os mostraré como publicar InfoPaths a través del administrador y cómo meterle codigo por detrás a los formularios para sacarles mucho más partido.

Formularios InfoPath con SharePoint (2 de 3)

Creación de un formulario con nuestro diseñador de InfoPath

En este capitulo vamos a crear un formulario con InfoPath. Para agilizar el curso y no tener que crear todos los controles lo que voy a hacer es coger una plantilla ya implementada de las que me proporciona la herramienta. Vosotros podeis crearos una o utilizar una ya hecha, conforme os venga mejor. La finalidad de este post es que veais un poco por encima el entorno de desarrollo.

Lo primero que nos aparece cuando arrancamos el InfoPath es el asistente que nos solicita si queremos crear un formulario nuevo o a partir de una plantilla.

Una vez seleccionada la plantilla nos sale algo así:

En la derecha de la pantalla vemos las diferentes secciones con las que podemos trabajar:

Layout: nos permitirá definir la estructura de nuestro informe:

Controls: Nos permitirá añadir controles a nuestro formulario. Como podreis apreciar no son controles extremadamente avanzados pero son suficientes para la implementación de estos formularios.

Data Source: Nos permitirá configurarnos origenes de datos para cargar información en el formulario. Los veremos más adelante. Las conexiones a origenes de datos que nos podremos crear son conexiones para RECIBIR datos o para ENVIAR datos (tambien conocidas estas ultimas como SUBMIT CONNECTIONS). Las conexiones para recibir datos nos van a permitir consultar un origen de datos, obtener la informacion que queramos, y cargar esos datos en un control, como podria ser un Combo. Podemos recibir informacion de un XML, de una lista de sharepoint, de un Web Service o de una base de datos SQL. Si la base de datos fuera Oracle deberiamos cargarnos nuestros datos a partir de un servicio web que accediera a la Base de Datos.

Views: Diferentes vistas para nuestro formulario

Design Checker: Nos ayudará a validar si nuestro formulario será 100% compatible cuendo lo hayamos integrado en SharePoint.

Publish From Template: Asistente de publicación. Será el ultimo paso una vez tengamos nuestro informe creado.

Como ejemplo de origenes de datos vamos a cargarnos los datos de una lista en un combo de nuestro formulario. Me he creado una lista donde tengo insertados diferentes años:

Lo que vamos a hacer es crearnos un combo en el formulario y añadirle estos años para que el usuario pueda seleccionarlos. Insertaremos el control en el formulario. Para ello nos vamos a la seccion "Controls" de InfoPath

hemos insertado el control y se llama 'fechas'. Ahora tenemos que crearnos el origen de datos. Pinchamos en la Seccion "Data sources" (Tools --> Data connections) y nos creamos una conexion nueva. La conexion que hay por defecto es la de submit para guardar el formulario y viene creada por defecto en la plantilla que estoy utilizando. Si el formulario se empieza desde cero esta conexion tendremos que crearnosla.

Pulsamos en "Añadir". Le indicaremos que queremos una conexion para recibir datos, ya que queremos cargar informacion en nuestro combo:

Le indicamos cual va a ser nuestro origen de datos. En este caso será una lista de Sharepoint:

Ahora tenemos que localizar nuestra lista. Para ello le indicamos en qué Site se encuentra. Le pongo la URL de mi Site:


Si la ruta es correcta me mostrará un listado con todas las listas, librerias, etc, que posee mi site y que pueden servirme de origen de datos. Como podreis apreciar sale mi lista de fechas pero tambien mi libreria de formularios:

Seleccionamos la lista de fechas y automaticamente me pide que le indique que columna/s van a ser mi origen de datos. Para este ejemplo los años los tenia en la columna 'Title' y como a priori no voy a necesitar mas columnas seleccionaré solo esa:

En esta ultima sección nos aparece un Checkbox crucial. Se trata de una opción con la que determinaré si los datos los voy a coger del origen de datos cada vez que cargue el formulario o por el contrario los voy a cargar la primera vez y luegolos almacenaré en mi plantilla. Es fundamental saber qué tipo de datos vamos a almacenar porque si estos datos no vana variar en el tiempo conviene guardarlos en la plantilla ya que nuestro formulario se nos cargará más rápido. Si los cambios tienden a variar en el tiempo lo que debemos hacer es no marcar esta opción, de esta forma, cada vez que el formulario se cargue cogerá los datos del origen correspondiente, con lo que siempre estarán actualizados. Para este ejemplo, por ser años y saber que no vana a cambiar lo que haré será guardarlos en la plantilla. Dejaré marcada la opción:

Pulsamos siguiente y ya tenemos nuestro origen de datos creado:

Ahora solo tenemos que asociarselo a nuestro combo. Seleccionamos el combo, boton derecho --> Propiedades del combo. En las propiedades nos saldrá una pantalla como esta:

En la seccion de "List box entries" podemos insertar los valores del combo manualmente, coger datos de otros controles de nuestro formulario o indicarle qué origen de datos queremos. Para el ejemplo seleccionaremos la tercera opción:

Como origen de datos nos marcará nuestro origen recien creado, ya que es el unico que tenemos. Lo marcamos y ahora tenemos que decir cual de los campos que contiene ese origen de datos que el que nos interesa:

Una vez seleccionado aplicamos los cambios y previsualizamos nuestro formulario. Podremos ver que él combo carga los datos correctamente:

Una vez creado el formulario (habrá una sección específica de como utilizar los diferentes controles) y teniendo ya creada nuestra libreria de formularios unicamente nos flatará publicar. (ver capitulo 3)

Formularios InfoPath con SharePoint (1 de 3)

Creación de una Form Library para poder albergar nuestro InfoPath

En este primer capitulo vamos a crearnos la librería que albergará nuestro formulario. Para los ya iniciados este capítulo es trivial y podeis pasar directamente al 2, donde nos meteremos más en profundidad en el asunto. Pero para los no iniciados aún es posible que os venga bien.

Para empezar yo me he creado una Web Application y dentro de ella una Site Collection, que es donde voy a ir almacenando mis diferentes Sites. Para el curso lo que haremos será crearnos un Site dentro de esta Site Collection. Este Site le pondremos de nombre "Formularios". Para ello nos iremos a "Site Actions" --> "Site Settings" --> "Sites and Worspaces" :

Insertamos el nombre, descripcion, etc del site:


Esta sección nos va a permitir poder insertar nuevos Sites a nuestra solución, de manera que tendremos la estructura necesaria para poder albergar nuestros formularios. Una vez creado el Site insertaremos una libreria de formularios (Form Library) para insertar nuestro formulario InfoPath. Pincharemos en "View All Site Content" y despues le daremos a "Create". Una vez dentro de esta sección pincharemos en "Form Library":

En el asistente le indicaremos el nombre de la libreria y el tipo de plantilla que utilizaremos. Por defecto nos pondrá la de InfoPath, a menos que tengamos instalado algún otro servicio. Yo para mi ejemplo únicamente tengo el de InfoPath:

Nuestro Site tendrá más o menos este aspecto:

Donde tendremos un Site (Formularios) y una Form Library (FormularioInfoPath).
En el siguiente capitulo conoceremos el entorno donde crearemos los formularios: InfoPath 2007

Formularios InfoPath con SharePoint

En este minicurso de 3 capitulos vamos a ver InfoPath como motor de creación de formularios y de qué manera podemos integrarlo con nuestro SharePoint para poder sacarle el máximo partido:

Capitulo 1.- Creación de una Form Library para poder albergar nuestro InfoPath
Capitulo 2.- Creación de un formulario con nuestro diseñador de InfoPath
Capitulo 3.- Publicación de nuestro formulario en nuestra librería.