Quería compartir con todos mis lectores, que desde el día de hoy, podréis seguir mis entradas tanto desde mi nuevo blog en Geeks.ms, como en éste.

Algunos de vosotros os estareis preguntando ¿Qué es eso de Geeks.ms? Por explicarlo brevemente, es un comunidad en la que miembros relevantes de la comunidad en torno a las tecnologías de Microsoft comparten sus conocimientos, y aunque actualmente no sea un miembro relevante, tengo la oportunidad de compartir y aprender con ellos y de ellos.

Un Saludo a todos, y nos vemos en Geeks.ms

Me apunto estos enlaces en el blog, para encontrarlos luego fácilmente…

Os dejo unos enlaces que pueden ser de utilidad:

Tablas de la Base de Datos de Contenido

Tablas de la Base de Datos de Configuración

Tablas de la Base de Datos

Procedimientos almacenados

En una próxima entrada comentare como crear una definición de sitio, y muchas de las features no documentadas por Microsoft, que permiten realizar la mayoría de las opciones que se muestran en la página de “Configuración de Sitio”. En esta entrada, veremos que utilizar las definiciones que proporciona microsoft, para crear una colección de sitios con subsitios en varios niveles, empleando únicamente los ficheros xml de configuración.

La estructura que crearemos será la siguiente:

Una vez tenemos clara la estructura que vamos a crear, únicamente necesitamos crear 2 ficheros xml:

webtempMySiteProvider.xml: (ubicado en 12/TEMPLATE/3082/XML) en este fichero, definiremos la definición de sitio que se va a emplear. No hay que crear una definición de sitio como tal, lo que pretendemos es que aparezca en la página de creación de sitios. A continuación se muestra el contenido del fichero:

<Templates xmlns:ows="Microsoft SharePoint">
  <Template Name="MySiteProvider" ID="10900">
    <Configuration ID="0" Title="Estrucutura desde xml" Hidden="FALSE" ImageUrl="/_layouts/images/stsprev.png" Description="Definicion que creaa toda la estructura de la coleccion de sitios" ProvisionAssembly="Microsoft.SharePoint.Publishing, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" ProvisionClass="Microsoft.SharePoint.Publishing.PortalProvisioningProvider" ProvisionData="xml\\estructura.xml" RootWebOnly="TRUE" DisplayCategory="MiTopologia" />
   </Template>
</Templates>

Como se puede ver, aparentemente se trata de una definición de sitio básica, salvo por las propiedades:

• ProvissionAssembly: especifica que librería se utilizará para el aprovisionamiento del sitio.
• ProvissionClass: especifica que clase se utilizará para el aprovisionamiento del sitio.
• ProvisionData: especifica el fichero que proporciona los datos para el aprovisionamiento. En nuestro caso estructura.xml

estructura.xml: (ubicado en 12/TEMPLATE/3082/XML) en este fichero se especifica la estructura que hay que crear, utilizando el esquema PortalSchema.xsd. Mediante el uso de y especificaremos los sitios y subsitios que se van a crear. El fichero estructura.xml, con la estructura especificada en la imagen, quedaría de la siguiente forma:

<?xml version="1.0" encoding="utf-8" ?>
<portal xmlns="PortalTemplate.xsd">
  <web name="Inicio" siteDefinition="CMSPUBLISHING#0" displayName="Inicio" description="Inicio" >
    <webs>
      <web name="sitio1" siteDefinition="STS#0" displayName="Sitio 1" description="Sitio 1"/>
      <web name="sitio2" siteDefinition="MPS#0" displayName="Sitio 2" description="Sitio 2"/>
      <web name="sitio3" siteDefinition="STS#1" displayName="Sitio 3" description="Sitio 3"/>
       <webs>
        <web name="blog" siteDefinition="BLOG#0" displayName="Blog" description="Blog"/>
        <web name="wiki" siteDefinition="WIKI#0" displayName="Wiki" description="wiki"/>
       </webs>
      </web>
      <web name="sitio4" siteDefinition="SRCHCEN#0" displayName="Sitio 4" description="Sitio 4"/>
      <web name="sitio5" siteDefinition="SPSREPORTCENTER#0" displayName="Sitio 5" description="Sitio 5"/>
    </webs>
  </web>
</portal>

En el caso del ejemplo, se utilizan las definiciones de sitio que proporciona Microsoft, pero del mismo modo se puede utilizar con las definiciones que creemos, y de ésta forma, podremos crear la estructura que necesitemos empleando nuestras definiciones de sitio.

Compatibilidad CSS con IE

Además existe otras páginas donde nos explican como poner estilos para que únicamente los entienda Internet Explorer.

Desarrollo web – Estilos para IE

Desarrollo web – Estilos

Este problema se debe a que cuando se envía el formulario, se llama a la función WebForm_OnSubmit y desde ahí a la función _spFormOnSubmitWrapper (en el init.js).  Precisamente en ésta función se verifica si la variable _spFormOnSubmit se ha puesto a true, y en ese caso, se cancelan las peticiones de envió. Imagino que este mecanismo evita que se produzcan múltiples envíos del formulario ante un doble click del usuario.

La solución consta de dos pasos:

• Asignar en el evento del botón (en el lado del cliente) a: 

exportRequested=true;

• Añadir las siguientes líneas en el evento de carga (page_load) del control de usuario/pagina/webpart

string beforeSubmitJS = "var exportRequested = false; ";
beforeSubmitJS += "var beforeFormSubmitFunction = theForm.onsubmit;";
beforeSubmitJS += "theForm.onsubmit = function(){ ";
beforeSubmitJS += "var returnVal = beforeFormSubmitFunction();";
beforeSubmitJS += "if(exportRequested == returnVal){_spFormOnSubmitCalled=false; exportRequested=false;}";
//beforeSubmitJS += "alert(returnVal + '\\n' +_spFormOnSubmitCalled);";
beforeSubmitJS += "return returnVal;";
beforeSubmitJS += "};";
//beforeSubmitJS += "alert(theForm.onsubmit);";
this.Page.ClientScript.RegisterStartupScript(this.GetType(),"alterFormSubmitEvent", beforeSubmitJS, true);

Espero que os ayude.

• Move from ASP to ASP.Net: proporciona una visión general de ASP.Net para desarrolladores de ASP.
• Learn ASP.Net for PHP developers: proporciona una visión general de ASP.Net para desarrolladores PHP:
• Web Development with ASP.Net: proporciona una introducción al desarrollo web con ASP.Net.
• Develop Windows Mobile 6 applications: proporciona una introducción al desarrollo de aplicaciones para móviles
• SharePoint for Developers: proporciona una visión general de cómo  desarrollar para MOSS. Trata temas como webparts, listas, event handlers, workflows, servicios web…

Bueno, todo esto y mucho más en Microsoft Rampup.

Esta tarea, era más compleja en SharePoint 2003, pero ahora gracias al nuevo modelo de objetos y los métodos que ofrecen, podemos realizar una impersonación mediante la cual podremos ejecutar código que realice acciones para las cuales el usuario actual no tiene permisos. El modelo de objetos proporciona dos formas de realizar esta tarea:

• Utilizando la cuenta del sistema: ejecutaremos el código con los permisos que tiene la cuenta del sistema en el sitio (FullMask), de modo que podremos realizar todas las acciones.
• Utilizando los datos de otro usuario: ejecutaremos el código con los permisos que tiene la cuenta del usuario utilizado en el sitio.

A continuación veremos que se realiza esta tarea y algunos aspectos a tener en cuenta.

En el primer caso, impersonar utilizando la cuenta del sistema, vamos a crear un nuevo elemento de una lista con un usuario lector. Para realizar la impersonación utilizamos el método RunWithElevatedPrivileges de la clase estática SPSecurity.

SPSecurity.RunWithElevatedPrivileges(delegate()
{
 using (SPSite miSitio = new SPSite("http://urlServidor"))
 {
  miSitio.AllowUnsafeUpdates = true;

  using (SPWeb miWeb = miSitio.OpenWeb())
  {
   miWeb.AllowUnsafeUpdates = true;
   SPList miLista = miWeb.Lists["Pruebas"];
   SPListItem elemento = miLista.Items.Add();
   elemento["Title"] = "PRUEBA CON USUARIO LECTOR";
   elemento.Update();
   miweb.AllowUnsafeUpdates = false;
  }
  miSitio.AllowUnsafeUpdates = false;
 }
});

En el caso de querer utilizar otro usuario, se puede realizar la impersonación de forma similar:

SPUser miUsuario = SPContext.Current.Web.AllUsers["miDominio\\ccanov"];
SPSite sitioImpersonado = new SPSite("http://urlServidor", miUsuario.UserToken);
SPWeb webImpersonada = sitioImpersonado.OpenWeb();

En ambos casos, si se obtiene el usuario llamando al método CurrentUser del objeto SPWeb impersonado, se obtendrá el usuario con el que se ha impersonado, siendo en el primer “SHAREPOINT\\SYSTEM” y en el segundo “miDominio\\ccanov”, mientras que si se realiza la llamada al objeto del contexto SPContext.Current.Web.CurrentUser, el usuario será el que está accediendo realmente a la página.

Hay que realizar siempre el Dispose de los objetos que se han utilizado para la impersonación, ya sea mediante el uso de using (primer ejemplo) o mediante el uso del método Dispose (segundo ejemplo).

En el caso de tener que realizar modificaciones, ya sea de listas, elementos de listas, páginas,… hay que poner la propiedad AllowUnsafeUpdates a true, antes de realizar la acción, y ponerla a false después, para esto, es recomendable hacer uso de finally e introducir todo el código dentro de un try-catch, para evitar que esta propiedad se quede con el valor a true.

Para hacer uso de esta clase, es necesario incluir la siguiente línea:

using Microsoft.SharePoint.Utilities;

Antes de comentar algunos de los métodos que proporciona, destacar que una de las ventajas de esta clase, es que al tratarse de una clase estática, no necesitamos instanciarla, lo cual facilita el acceso desde cualquier parte de nuestro código. A continuación describo la utilidad y como utilizar algunos de los métodos de ésta clase:

• EnsureSiteAdminAccess: éste método permite validar si el usuario actual es administrador del sitio al que accede. Existen otros métodos para validar esto, pero lo interesante es que en este caso, si no se trata del un usuario administrador, aparecerá la ventana de login tres veces, dando la opción al usuario a acceder con otra cuenta. En caso de que el usuario no tenga acceso, se le enviará a la página de acceso denegado. En el código del ejemplo, se utiliza un control de usuario que estará cargado en un webpart.

protected void Page_Load(object sender, EventArgs e)
{
    SPUtility.EnsureSiteAdminAccess(SPContext.Current.Web);
    //Resto del código
}

• GetGenericSetupPath: ¿quién no ha necesitado alguna vez la famosa ruta hasta el directorio 12? Este método nos devuelve la ubicación del directorio de instalación, en la mayoría de los casos es c:\Program Files…\….\12 pero no queda demasiado bien dejar el código con estas ruta y si cambia necesitaremos realizar modificaciones. En el caso del ejemplo, obtenemos la ruta hasta la carpeta features.

string directorioFeature= SPUtility.GetGenericSetupPath("template\\features");

• SendEmail: permite enviar correos electrónicos haciendo uso de las configuraciones de la granja.

string subject = "Correo electronico de notificación de " + SPContext.Current.Web.Title;
string body = "El cuerpo del correo electronico a enviar";

SPUtility.SendEmail(SPContext.Current.Web, false, false, "miemail@miemail.com", subject, body);

• TransferToErrorPage y TransferToSuccessPage:permiten redirigir a las páginas por defecto de error o bien de operacón realizada con éxito.

Evidentemente no son todos los métodos ya que la idea principal es ver como se pueden utilizar éstos métodos.

Finalmente, recomiendo que visitéis en el SDK los métodos y propiedades que proporciona ésta clase, aunque aviso que no todos están documentados.

SDK Clase SPUtility

En primer lugar es necesario añadir referencias a las siguientes librerías:

• Microsoft.SharePoint.dll
• Microsoft.Office.Server.dll
• Microsoft.Office.Server.Search.dll

Y haremos uso de los siguientes Namespaces:

using Microsoft.Office.Server;
using Microsoft.Office.Server.Search.Administration;
using Microsoft.SharePoint;

En primer lugar es necesario obtener los contextos del servidor y el proveedor de servicios compartidos mediante los cuales, tendremos acceso a las reglas de rasteo. Cabe destacar, que se debe reemplazar “ShareServices1” por el servidor de recursos compartidos correspondiente a vuestra instalación.

//Obtenemos el provedor de servicios compartidos
ServerContext ContextoServidor = ServerContext.GetContext("SharedServices1");
SearchContext ContextoBusqueda = SearchContext.GetContext(ContextoServidor);
Content sspContent = new Content(ContextoBusqueda);

Una vez tenemos los elementos necesarios para acceder a las reglas de rastreo, se crea la regla:

string regla = "http://*/SiteCollectionImages/*";

//Comprobamos que la regla no existe
if (!sspContent.CrawlRules.Exists(regla))
{
CrawlRule crawlRule = null;

//Creamos la regla de inclusión
crawlRule = sspContent.CrawlRules.Create(CrawlRuleType.InclusionRule, regla);
//o bien, de exclusión
crawlRule = sspContent.CrawlRules.Create(CrawlRuleType.ExclusionRule, regla);

//Si queremos marcar el check en Seguir urls complejas
if (crawlRule != null)
crawlRule.FollowComplexUrls = true;

//Finalmente actualizamos la regla con las modificaciones creadas
if(crawlRule != null)
crawlRule.Update();
}

De esta forma, se pueden crear reglas de rastreo desde una característica, webpart o cualquier otro elemento, siempre y cuando el usuario que lo ejecute disponga de los permisos necesarios (aunque siempre estará disponible la impersonación o elevación de permisos).

En el caso de querer realizar modificaciones sobre reglas existentes o bien eliminar alguna de las reglas, el procedimiento es prácticamente el mismo.

CrawlRule crawlRule2 = sspContent.CrawlRules[regla];
crawlRule2.Delete();

Dejo unos enlaces, donde podéis ampliar información:

Mircosoft Office Server Namespace

Microsoft Office Server Search Administrator Namespace

Microsoft SharePoint Namespace

Se puede utilizar desde una página o control de usuario en aspx, de modo que todo lo que esté dentro de la etiqueta sólo se mostrará si esta en el modo que se especifica en la propiedad.

<PublishingWebControls:EditModePanel runat=server id="idEditPanel" PageDisplayMode="Display">

<!- – Controles definidos en esta zona se muestran en modo visualización – ->

</PublishingWebControls:EditModePanel>

<PublishingWebControls:EditModePanel runat=server id="idEditPanel1" PageDisplayMode="Edit">

<!- – Controles definidos en esta zona se muestran en modo edición- ->

</PublishingWebControls:EditModePanel>

Si se necesita realizar la comprobación mediante código fuente:

if( SPContext.Current.FormContext.FormMode == SPControlMode.Edit)

Cabe destacar que en el caso de los webparts, será necesarios utilizar la propiedad de WebPartManager.DisplayMode

Dejo unos enlaces para ampliar la información.

WebPartManager.DisplayMode Property

SPControlMode Enumeration