El blog de Jordi Ruiz

IEnumerable en vez de List para propiedades

2011-12-02T04:02:00.001-08:00

Hoy toca un post muy sencillo y básico pero que puedes preguntarte en algunas ocasiones.

Hoy le he hecho una pregunta a mi amigo y maestro Pedro Santos que me estaba rondando por la cabeza, ¿por qué exponer una propiedad como IEnumerable en vez de List, si yo internamente la voy a definir como una List?

Su respuesta ha sido muy clarificadora:

Al exponerla como IEnumerable tu no expones (encapsulas) su estructura interna, además así limitas las operaciones a realizar con esta propiedad y puedes aplicar las reglas de negocio que te interesen, como por ejemplo, que tenga un cierto comportamiento concreto al añadir un nuevo elemento a la lista.

Si tu expones una propiedad como List, también le estas exponiendo la opción de añadir sin que tu controles como se han de añadir estos elementos a tu colección.

Pues bueno, a partir de ahora, todas mis colecciones irán como IEnumerable y cuando me interese le expondré el método AddNewFooItem(FooItem item). Por último, lo ideal también sería exponer el setter de la lista como private o protected, para que no puedan “settearte” una nueva colección.

Llamando a un web service sobre https (ssl) desde sharepoint 2010

2011-11-03T04:31:00.001-07:00

He estado trabajando en un proyecto donde teniamos que integrar una aplicación externa, esta integración la hacemos mediante servicios webs. Estos servicios webs contienen datos privados por lo que están securizados mediante certificados (el mensaje) y además la información viaja por un medio seguro, es decir, ssl.

Bueno hasta aquí nada nuevo, hice mis pruebas con un proyecto de test, colocando los certificados en los diferentes repositiorios, dependiendo de su función: Trusted Root Certification Authorities, Intermediate Certification Authorities, etc. y todo funcionaba a las mil maravillas.

Pero esta llamada al servicio web ha de ser hecha desde un entorno SharePoint 2010, pensé que esto no sería ningún problema pues en el otro tipo de proyecto me funcionaba correctamente, pero no fue así, de pronto observé que la llamada al servicio web me estaba devolviendo la siguiente excepción:

Type: System.Net.WebException
Message: The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel.
InnerException: The remote certificate is invalid according to the validation procedure.

Esta excepción me extraño mucho, pues si yo accedía mediante el browser a la url del web service me decía que el certificado estaba correctamente instalado.

Entonces empecé a googlear un poco y leía gente que decía de crear un bypass, mediante la creación de tu propia clase CertificatePolicy que implemente la interfaz ICertificatePolicy, y en el método CheckValidationResult devolver true siempre para que se salte la validación.

public class TrustAllCertificatePolicy : System.Net.ICertificatePolicy
{
 public TrustAllCertificatePolicy()
 {}

 public bool CheckValidationResult(ServicePoint sp,
  X509Certificate cert,WebRequest req, int problem)
 {
  return true;
 }
}

La llamada a esta clase se tendría que hacer justo antes de la llamada a tu servicio web.

System.Net.ServicePointManager.CertificatePolicy = new TrustAllCertificatePolicy();

He visto en muchos foros y blogs que esto lo daban como la solución correcta, pero ojo, aquí estamos aceptando cualquier cosa que nos esté enviando el servidor sin validar el certificado!!

Por lo tanto seguí buscando y el problema reside en la forma que tiene sharepoint de obtener los certificados raíz, que parece ser que usa su propio repositorio de certificados en vez de usar el de la propia máquina. Por lo que tendremos que añadir estos certificados raíz de confianza en el repositorio de sharepoint. Para hacerlo seguiremos los siguientes pasos:

Ir a la administración central

Ir a security

Manage trust

Aquí es donde instalaremos los certificados raíz que nos interese, pulsando new, buscando el certificado y poniéndole un nombre.

Esta información la obtuve del siguiente blog:

http://blog.mattsampson.net/index.php/calling-a-webservice-over-ssl-in-sharepoint-ssl?blog=1

WCF tools

2011-06-09T09:53:00.001-07:00

Esta semana ~~me he estado peleando~~ he estado haciendo una integración con un proveedor de servicios para poder consumir su servicio una aplicación que estamos desarrollando. Lo primero que hemos de saber es que toda integración suele ~~dar muchos dolores de cabeza~~ ser un bonito reto.

En nuestro caso teníamos que consumir un servicio elaborado con java axis2. Este servicio tenia que tener seguridad a nivel de transporte (mediante certificado) y seguridad a nivel de mensaje (también mediante certificado), más concretamente en nuestro caso debía contener una firma.

Cuando hacemos este tipo de integraciones lo más normal es que no nos salga a la primera y que tengamos que ver que mensajes estamos enviando al servidor, ya que los errores que nos pueden devolver el servidor pueden ser poco intuitivos. Y he aquí donde realmente empieza el contenido de este post, o sea, que herramientas podemos usar para ver lo que estamos enviando.

Una de las primeras herramientas que podemos utilizar es el tracing de Windows Communication Foundation. En la siguiente página de las MSDN podemos ver como configurar esto:

http://msdn.microsoft.com/en-us/library/ms733025.aspx

En mi caso la configuración ha sido la siguiente:

Justo antes del cierre del tal configuration (</configuration>)

<system.diagnostics>
  <sources>
    <source name="System.ServiceModel"
            switchValue="Information, ActivityTracing"
            propagateActivity="true" >
      <listeners>
        <add name="xml"/>
      </listeners>
    </source>
    <source name="System.ServiceModel.MessageLogging">
      <listeners>
        <add name="xml"/>
      </listeners>
    </source>
  </sources>
  <sharedListeners>
    <add name="xml"
         type="System.Diagnostics.XmlWriterTraceListener"
         initializeData="C:\logs\CommandLineSTS.svclog" />
  </sharedListeners>
</system.diagnostics>

Y esto dentro del nodo system.serviceModel:

<!-- add trace logging -->
<diagnostics wmiProviderEnabled="true">
  <messageLogging
       logEntireMessage="true"
       logMalformedMessages="true"
       logMessagesAtServiceLevel="true"
       logMessagesAtTransportLevel="true"
       maxMessagesToLog="3000"
    />
</diagnostics>

Otras herramientas que podemos usar para ver que se esa enviando son HTTP monitors, en mi caso he utilizado dos, destacando el último de los que menciono a continuación:

Fiddler: http://www.fiddler2.com/fiddler2/
HTTP Analyzer V6: http://www.ieinspector.com/httpanalyzer/

Otra de las cosas con las que nos entretendremos mucho es configurando nuestro service model a nivel de configuración o programándolo con código. Para ello nada mejor que las msdn y como punto de partida esta seria una buena página:

http://msdn.microsoft.com/en-us/library/ms733103.aspx

Tampoco podemos olvidar las herramientas de WCF que se nos ofrecen con nuestro visual studio, un resumen de ellas son las que indica la msdn en la siguiente página:

http://msdn.microsoft.com/en-us/library/ms732015(v=vs.90).aspx

Seguramente y debido a las peculiaridades de cada integración, no nos valdrá con las típicas configuraciones de bindings que nos ofrece el framework por defecto, es decir BasicHttpBinding o WSHttpBinding, entre otras, y tengamos que echar mano de custombindings, ahora bien no esta mal partir de uno de los bindings de los que disponemos, para poder hacer esto podemos convertir cualquiera de estos bindings a custom bindings utilizando por ejemplo una herramienta que expone en su blog un crack en la materia como es Yaron Naveh.

http://webservices20.blogspot.com/2009/08/bindingbox-convert-wcf-bindings.html

Sobre el tema de configuración, decir que antes de pensar en desarrollar nosotros una solución como dirian los anglosajones “from scratch”, mirar todas las posibilidades que nos ofrecen las configuraciones de los bindings, seguro que encontraremos alguna que satisface nuestras necesidades.

En caso de que nuestra solución sea muy compleja y no podamos obtenerla con lo que nos ofrece wcf out of the box, siempre podemos pensar en extender estas funcionalidades ya que wcf es un framework de comunicación altamente extensible. Por ejemplo, podemos crear un message inspector o un message encoder (derivando de la interfaz IClientMessageInspector o de la clase MessageEncoder, respectivamente). Para estas posibles extensiones que podamos hacer sobre WCF es interesante descargarnos los ejemplos que encontramos en la msdn, más concretamente en:

http://msdn.microsoft.com/en-us/library/ms751514(v=VS.90).aspx

Aquí podemos encontrar ejemplos divididos en las siguientes categorías:

Basic
Extensibility
Scenario
Setup
Tools

Alternativa a .NET Reflector

2011-04-18T07:49:00.001-07:00

Hoy toca una entrada muy cortita.

El otro día estuve buscando una alternativa open source a la famosa herramienta de Redgate .NET Reflector y encontré una que me ha gustado mucho. Al igual que .NET Reflector, se trata de una herramienta que nos permite navegar por los ensamblados y decompilar codigo IL.

Como podéis apreciar en la siguiente imagen, la interfaz es identica a .NET Refector, por lo que no nos costará nada acostumbrarnos a trabajar con esta nueva herramienta.

Por último os dejo la url de la herramienta:

http://wiki.sharpdevelop.net/ilspy.ashx

WCF: Windows Authentication and Impersonation

2011-03-31T07:31:00.001-07:00

Voy a intentar mostrar todo el procedimiento de poder exponer un servicio WCF alojado en un IIS con autenticación windows, esto es una tarea bien sencilla, pero muchas veces si “googleamos” un poco, nos encontramos con diferentes entradas en los foros y cada uno intenta hacerlo de una forma, al final acabas pensando que es una tarea dificil cuando en realidad no lo es. Acto seguido expondré como poder realizar una impersonación con el usuario que ha llamado a nuestro servicio.

Parte uno: creación WCF Service y publicación IIS

Lo primero que haremos será crear un proyecto de tipo WCF Service Application, en este proyecto tendremos nuestra interfaz que define el Service Contract con un método que define nuestro Operation Contract:

using System.ServiceModel;

namespace FooWcfService
{
    [ServiceContract]
    public interface IFooWcfService
    {
        [OperationContract]
        string FooOperation();
    }
}

Ahora modificaremos la clase que implementa nuestro Service Contract (en este tipo de proyectos, esta clase esta en el code behind del fichero .svc), en nuestro caso algo parecido a esto:

namespace FooWcfService
{
    public class FooWcfService : IFooWcfService
    {
        public string FooOperation()
        {
            return "Hello World";
        }
    }
}

Muy bien, una vez tenemos implementado lo que hará nuestro servicio, hemos de empezar a tratar el tema de seguridad, en nuestro caso hemos dicho que tendremos autenticación windows. Para ello, tendremos que modificar el fichero web.config, y poner el siguiente binding:

<bindings>
      <basicHttpBinding>
        <binding>
          <security mode="TransportCredentialOnly">
            <transport clientCredentialType="Windows" />
          </security>
        </binding>
      </basicHttpBinding>
    </bindings>

Bueno, para que no haya dudas expondré todo el web.config:

<?xml version="1.0"?>
<configuration>

  <system.serviceModel>
    <bindings>
      <basicHttpBinding>
        <binding>
          <security mode="TransportCredentialOnly">
            <transport clientCredentialType="Windows" />
          </security>
        </binding>
      </basicHttpBinding>
    </bindings>
    <behaviors>
      <serviceBehaviors>
        <behavior>
          <serviceMetadata httpGetEnabled="true"/>
          <serviceDebug includeExceptionDetailInFaults="false"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <services>
      <service name="FooWcfService.IFooWcfService">
        <endpoint binding="basicHttpBinding" contract="FooWcfService.IFooWcfService" />
      </service>
    </services>
  </system.serviceModel>
  
</configuration>

Ahora sí, ya estamos preparados para publicar nuestro servicio en un IIS. Supongamos que ya tenemos un IIS instalado, y que tenemos un Default Web Site, entonces sólo tendremos que hacer botón derecho sobre nuestro proyecto y publish.

Por último tendremos que habilitar en el IIS nuestra seguridad windows, vamos a nuestra web site y suponiendo que tengamos la vista Feature View, hacemos click sobre Authentication y habilitamos Windows Authentication y deshabilitamos Anonymous Authentication.

Parte dos: Impersonación

Para esta parte haremos un pequeño ejemplo de una aplicación cliente (Console application) que consuma nuestro servicio. Y cambiaremos un poco nuestra operación, para que tenga sentido la impersonación. Imaginemos que queremos tener un acceso a un recurso (por ejemplo acceso de escritura en disco) y para ello hemos de garantizar que el usuario que llama a nuestro servicio tenga permisos para ello, esto sería un claro ejemplo de impersonación. No se hable más, vamos a poner un pequeño ejemplo de ello:

using System;
using System.IO;

namespace FooWcfService
{
    public class FooWcfService : IFooWcfService
    {
        public void FooOperation()
        {
            StreamWriter fileWriter = null;
            try
            {
                
                fileWriter = File.CreateText(@"C:\dummy.txt");
                fileWriter.Write("Hello world");

            }
            catch(Exception ex)
            {
                throw;
            }
            finally
            {
                if(fileWriter != null)
                    fileWriter.Close();
            }
        }
    }
}

Para configurar la impersonación lo podemos hacer de modo imperativo o de modo declarativo, aquí podemos ver la explicación, nosotros en el ejemplo, usaremos el modo declarativo.

Este modo es el más simple, simplemente hemos de poner el siguiente atributo en la implementación de nuestro operation contract:

[OperationBehavior Impersonation=ImpersonationOption.Required)]

Si ejecutamos nuestra aplicación de consola, sin esta impersonación, lo más seguro es que nos aparezca un mensaje como el que apunto a continuación:

Access to the path 'C:\dummy.txt' is denied.

En cambio, si ponemos el attributo anterior, nos vuelve a dar una excepción pero ahora es diferente:

Either a required impersonation level was not provided, or the provided impersonation level is invalid.

Este mensaje nos esta diciendo, que nosotros requeriamos un cierto nivel de impersonación en nuestro código, pero que no se esta cumpliendo con la llamada desde el cliente.

Por lo tanto, el cliente cuando haga una llamada a nuestro servicio, ha de indicar que permite la impersonación.

Pongo ahora en código completo del cliente, done permitimos esta impersonación.

using System;
using System.Security.Principal;
using FooConsoleApplication.FooWcfService;

namespace FooConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            FooWcfServiceClient client = null;

            try
            {
                client = new FooWcfServiceClient();
                client.ClientCredentials.Windows.AllowedImpersonationLevel = TokenImpersonationLevel.Impersonation;
                var result = client.FooOperation();
                
                Console.Write(result);
                Console.Read();
            }
            finally
            {
                if(client!= null)
                {
                    client.Close();
                }
            }
        }
    }
}

DataContracts and Constructors

2011-01-28T01:21:00.001-08:00

Imaginemos el siguiente escenario, tengo una clase que será un DataContract utilizado en un método de un servicio WCF y queremos inicializar una variable de esta clase en el constructor.

namespace FooNamespace
{
    [ServiceContract]
    public interface Foo
    {
        [OperationContract]
        void StartProcess(FooData dataEntrada);
    }

    [DataContract]
    public class FooData
    {
        [DataMember]
        public string FooProperty { get; set; }

        protected string InitializedData {get; set;}

        public FooData()
        {
            InitializedData = "Hello world!";
        }
    }
}

Bueno pues hemos de ser consciente que esa llamada al constructor no se llamará nunca durante la deserialización.

Por lo que si queremos simular esto podemos usar los Serialization Callbacks. De esta forma en el servidor podremos tener inicializada esa clase con el valor que queramos.

namespace FooNamespace
{
    [ServiceContract]
    public interface Foo
    {
        [OperationContract]
        void StartProcess(FooData dataEntrada);
    }

    [DataContract]
    public class FooData
    {
        [DataMember]
        public string FooProperty { get; set; }

        protected string InitializedData {get; set;}

        [OnDeserializing]
        public void Initialize(StreamingContext context)
        {
            InitializedData = "Hello world!";
        }
    }
}

Data Contract Known Types

2011-01-27T06:44:00.001-08:00

Hoy me he encontrado con un problemilla (bueno más que un problemilla era que desconocía la manera correcta de hacerlo) a la hora de desarrollar un sevicio WCF.

El problema era que quería construir un método que recibía por parametro un objeto de tipo x, pero quería ofrecer al cliente la opción de poder pasar como parámetro objetos derivados de tipo x que había construido. Yo habia declarado todas estas clases con el atributo [DataContract], pero parece ser que esto no era suficiente, sino que había que especificar en la clase base, que también podiamos pasar objetos derivados usando el atributo [KnownType(typeof(claseBase)]

Aquí va la solución:

using System;
using System.Runtime.Serialization;
using System.ServiceModel;

namespace FooNamespace
{
    [ServiceContract]
    public interface IFoo
    {
        [OperationContract]
        void DoSomething(FooDataBase dataEntrada);
    }

    [DataContract]
    [KnownType(typeof(FooDataDerived))]
    public class FooDataBase
    {
        [DataMember]
        public string FooProperty1 { get; set; }
    }

    [DataContract]
    public class FooDataDerived:FooDataBase
    {
        [DataMember]
        public string FooProperty2 { get; set; }
    }
}

Unit Testing con Pex and Moles

2011-01-26T06:49:00.001-08:00

Siguiendo la llamada de mi compañero Luis Ruiz, voy a entrar un poco en el mundo de Pex and Moles. A ver que es lo que me encuentro. Para ello empezaremos con una mini guia de tutoriales que voy a ir leyendo. Tal y como los vaya leyendo intentaré postear un pequeño resumen y las prácticas que voy realizando.

- Getting Started with Microsoft Pex and Moles: Aquí podemos ver lo que yo llamo un meta-tutorial, es decir, un tutorial de tutoriales, o más bien un tutorial que nos dice los siguientes pasos a realizar y que tutoriales podemos seguir.

En definitiva lo primero que deberiamos hacer es instalarnos Pex and Moles y continuar con otros tutoriales. Lo que me ha gustado es que nos muestra un conjunto de conceptos básicos sobre unit testing en forma de glosario de términos que puede ser muy útil para los neófitos, algunos de estos conceptos serian:

code coverage
integration test
mock
mole type
stub type
…

- Getting Started with Microsoft Code Contracts and Microsoft Pex: Este tutorial esta dividido en dos secciones, una primera en la que crearemos un proyecto en Visual Studio (una clase llamada StringExtensions con un método estático que devuelva un substring, desde el inicio hasta la primera aparición de otro string que nos pasen, también por parámetro) y ejecutamos lo que se conoce como Pex Explorations, esto lo que hace es ejecutar nuestro código muchas veces con diferentes valores de entrada, entonces se nos muestra una tabla con las diferentes salidas o excepciones de nuestro código. Para hacer eso sólo tendremos que hacer botón derecho en la función que queramos probar y hacer click en Run Pex.

Vemos que lo que hace Pex es intentar crear diferentes combinaciones de parámetros de entrada para cubrir la mayor parte de nuestro código. Entonces hace diferentes llamadas a nuestro método, pasándole como parámetros los que ha calculado, acto seguido nos muestra una tabla con estos resultados.

Obtener PublicKeyToken de una assembly

2010-12-16T04:42:00.001-08:00

Muchas veces, nos hemos encontrado con la necesidad de obtener el PublicKeyToken de una assembly para poderlo añadir por ejemplo a una directiva <%@ Page %> o <%@ Control %> de nuestra solución, esto se consigue mediante la herramienta sn.exe (Strong Name Tool).

Para usar esta herramienta sería necesario abrir una consola de visual studio y ejecutar esta herramient pasándole los parámetros apropiados. Podemos automatizar este proceso usando la opción de añadir una External Tool a nuestro Visual Studio, lo podemos hacer la siguiente forma:

En Visual Studio hacemos:

Menú Tools > External Tools
Pulsamos Add
Title: Get &PublicKeyToken
Command: C:\Program Files\Microsoft SDKs\Windows\v6.0A\Bin\sn.exe
Arguments: -Tp $(TargetPath)
Marcamos la opción “Use Output Window”
Pulsamos OK

Con este procedimiento se nos ha añadido una nueva opción de menú en el menú Tools con el nombre Get PublicKeyToken. Y voilà ya podemos obtener nuestro publicKeyToken del proyecto en el que estemos situados.

Fuente: http://blogs.msdn.com/b/kaevans/archive/2008/06/18/getting-public-key-token-of-assembly-within-visual-studio.aspx

Reflection y como ser un Jedi (Parte 3)

2010-12-01T01:02:00.001-08:00

En el anterior post vimos la potencia de Reflection a la hora de preguntar por sus métodos, propiedades, variables, etc. a un ensamblado y además hubo un poco de teoría en cuanto a conceptos como MSIL, CLR, JIT, etc., eso sí, muy básica. Para más información Google.

Por último decir, que la potencia sin control no sirve de nada, con reflection la línea que hay entre la fuerza y el lado oscuro es muy delgada. Es decir con un par de líneas de código nos podemos saltar muchos principios de los lenguajes orientados a objetos, como por ejemplo la encapsulación. Reflection nos permitiría invocar a un constructor privado, o invocar a un método privado, o obtener las variables privadas de cualquier classe. Por eso, tenemos que ser muy conscientes de que estamos tocando con reflection.

Reflection y como ser un Jedi (Part 2)

2010-12-01T00:51:00.001-08:00

Resumen: En la entrada anterior vimos una definición de reflection y los namespaces necessarios, para trabajar con reflection. Más adelante se vió algunos ejemplos de cómo crear objetos y como consultar los diferentes constructores de un tipo determinado.

Hecho este pequeño recordatorio vamos a ver que más cosillas podriamos hacer con reflection y subir así un nivel en nuestro curso de Jedi, a saber, ser un Padawan.

Haciendo algún pequeño cambio a nuestro programa, podemos consultar también los métodos, propiedades y variables (fields) de nuestro código.

EJEMPLO 2:
Vamos a ver que métodos tiene nuestra StupidClass:

using System;
using System.Reflection;

namespace StupidNameSpace
{
    public class Program
    {
        static void Main(string[] args)
        {
            // Obtenemos el tipo, tenemos que pasadle todo el fully qualified name,
            // tened en cuenta que estamos en el mismo namespace, y en el mismo assembly, sino fuera así,
            // tendriamos que pasarle, el nombre del assembly.
            var type = Type.GetType("StupidNameSpace.StupidClass");

            MethodInfo[] methods = type.GetMethods();
            foreach (MethodInfo mi in methods)
            {
                Console.WriteLine(string.Format("Method name: {0}",mi.Name));
                if(mi.IsPrivate) Console.WriteLine("Private");
                else Console.WriteLine("Public");
                if(mi.IsStatic) Console.WriteLine("Static");
                
                if (mi.IsVirtual) Console.WriteLine("Virtual");
                var parameters = mi.GetParameters();
                if(parameters.Length > 0) Console.WriteLine("Parameters:");

                foreach(ParameterInfo pi in parameters)
                {
                    Console.WriteLine(string.Format("--> Parameter name: {0}",pi.Name));
                    Console.WriteLine(string.Format("--> Parameter type: {0}",pi.ParameterType));
                }
            }

            Console.Read();
        }
    }
}

Cómo se puede observar no supondría ninguna complicación mostrar las propiedades utilizando el método GetProperties que devuelve un array de PropertyInfo o el mostrar los fields utilizando el método GetFields que a su vez devuelve un array de FieldInfo.

Es más, podriamos usar el método GetMethodBody() de la clase MethodInfo, que nos prové acceso a los metadatos y al MSIL del método.

Recordad MSIL significa Microsoft Intermediate Language, es el código que se genera al compilar nuestra aplicación, este código no es un lenguaje máquina en sí, bueno es un “lenguaje máquina” capaz de ser leído por el CLR (Common Language Runtime, “la máquina virtual de .NET”), éste código, será transformado en verdadero código máquina para nuestra procesador por el JIT (just-in-time compiler) que es un componente del CLR.

De esta forma podriamos crearnos un lector de código MSIL, para obtener el código MSIL de los ensamblados que queramos. Es interesante ver algunos ejemplos de esto mismo en:

http://blogs.msdn.com/b/haibo_luo/archive/2005/10/02/476242.aspx

http://www.codeproject.com/KB/cs/sdilreader.aspx

Aquí obtenemos una buena explicación del MSIL:

http://www.codeproject.com/KB/msil/ilassembly.aspx

Llegados a este punto decir que disponemos de una maravillosa herramienta, llamada .Net Reflector que va un paso más allá y nos permite obtener tanto el código MSIL de un assembly, como el código de alto nivel C#, VB, etc.

Reflection y cómo ser un Jedi (Part 1)

2010-10-19T06:18:00.001-07:00

¿Qué es reflection?

Respuesta wikipedia: "Reflection es el proceso por el cual un programa puede observar y modificar su propia estructura o comportamiento en tiempo de ejecución."

Respuesta maestro Jedi: "reflection es el control de la fuerza."

Respuesta serie Numb3rs: "Usamos reflection todos los días, al usar el IntelliSense, para debuggar, al usar contenedor IoC. También lo usamos para añadir webparts, para inspeccionar el código y para predecir su comportamiento. Con reflection podemos solucionar los misterios que se nos planteen."

¿Qué debemos hacer para empezar a utilizar la fuerza?

Existe un namespace llamado System.Reflection y una clase conocida como System.Type que nos acompañaran, en esta, fabulosa aventura hacia el interior del código.

Y así, sin más, ¿puedo empezar a usarlo?

Claro, pero no esperes aquí una clase magistral… <tono de Bilbao> ¡¡que somos desarrolladores joder!!</tono de Bilbao>. Dame un ~~punto de apoyo~~ HelloWorld y ~~moveré el mundo~~ conoceré toda la sintaxis.

Así que aquí van unas cuantos ejemplos, para la explicación vamos a utilizar una clase estúpida dentro de un namespace estúpido.

namespace StupidNameSpace
{
    public class StupidClass
    {
        private string _field1;
        private string _field2;

        public StupidClass()
        {
        }

        public StupidClass(string field1, string field2)
        {
            _field1 = field1;
            _field2 = field2;
        }

        public string Field1
        {
            get { return _field1; }
            set { _field1 = value; }
        }

        public string Field2
        {
            get { return _field2; }
            set { _field2 = value; }
        }

        public string FooMethod1()
        {
            return string.Empty;
        }

        public string FooMethod2(string parameter)
        {
            return parameter;
        }
    }

Ahora vamos a crear una pequeña aplicación de consola para interrogar, utilizando la fuerza (reflection), a nuestra clase.

Ejemplo 1:
En el primer ejemplo vamos a crear un objeto de tipo StupidClass, usando el constructor público sin parámetros y luego utilizando el constructor con parámetros.

using System;
using System.Reflection;

namespace StupidNameSpace
{
    public class Program
    {
        static void Main(string[] args)
        {
            // Obtenemos el tipo, tenemos que pasadle todo el fully qualified name,
            // tened en cuenta que estamos en el mismo namespace, y en el mismo assembly, sino fuera así,
            // tendriamos que pasarle, el nombre del assembly.
            var type = Type.GetType("StupidNameSpace.StupidClass");
            // Podriamos haber usado:
            // var type = typeof(StupidClass);

            // Usamos el constructor sin parámetros (default constructor) para crear un objecto llamado
            // myStupidObject
            var types = new Type[0];
            var constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, types, null);
            var myStupidObject = (StupidClass)constructorInfo.Invoke(null);

            // Ahora hacemos lo mismo pero llamamos al constructor que recibe 2 parámetros
            // y creamos un objeto llamado myStupidObject2
            types = new Type[2];
            types[0] = typeof (string);
            types[1] = typeof (string);

            var parameters = new object[2];
            parameters[0] = "param1";
            parameters[1] = "param2";

            constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, types, null);
            var myStupidObject2 = (StupidClass) constructorInfo.Invoke(parameters);
        }
    }
}

Esto esta muy bien, pero porque sabemos que constructor tiene la clase, si es público o privado, si recibe parámetros, etc. Pero y si no lo sabemos. Pues preguntémosle.

using System;
using System.Reflection;

namespace StupidNameSpace
{
    public class Program
    {
        static void Main(string[] args)
        {
            // Obtenemos el tipo, tenemos que pasadle todo el fully qualified name,
            // tened en cuenta que estamos en el mismo namespace, y en el mismo assembly, sino fuera así,
            // tendriamos que pasarle, el nombre del assembly.
            var type = Type.GetType("StupidNameSpace.StupidClass");

            ConstructorInfo[] constructors = type.GetConstructors();
            foreach(ConstructorInfo ci in constructors)
            {
                Console.WriteLine("===========");
                Console.WriteLine("CONSTRUCTOR");
                Console.WriteLine("===========");
                Console.WriteLine(ci.Name);
                if(ci.IsPrivate) Console.WriteLine("Private");
                else Console.WriteLine("Public");
                if(ci.IsStatic) Console.WriteLine("Static");
                if(ci.IsAbstract) Console.WriteLine("Abstract");
                if (ci.IsVirtual) Console.WriteLine("Virtual");
                var parameters = ci.GetParameters();
                if(parameters.Length > 0) Console.WriteLine("Parameters:");

                foreach(ParameterInfo pi in parameters)
                {
                    Console.WriteLine("-->" + pi.Name);
                    Console.WriteLine("-->" + pi.ParameterType);
                }
            }

            Console.Read();
        }
    }
}

Error JavaScript en LookupField Control

2010-10-11T08:15:00.001-07:00

Hoy he estado peleándome con uno de esos errores que odias encontrar, ya que son de esos errores que cuesta un poco reproducir, y por lo tanto su resolución no se prevé facilona.

Voy a intentar situarlos en contexto:

Cuando mostramos un LookupField control, por ejemplo al editar un item de una lista que uno de sus campos es un lookup hacia otra lista (editform.aspx), éste se puede mostrar de dos maneras diferentes, una cuando la lista a la que hacemos el lookup tiene menos de 20 items o 20 items y otra cuando tiene más de 20 items. En el primer caso, el control muestra un DropDownList y en el segundo muestra un textbox, un par de literales y una imagen (para no hacer que el dropdown sea demasiado largo), con ciertas llamadas a funciones javascript.

Una de estas llamadas se ejecuta al hacer click en la imagen, concretamente es una llamada a la función ShowDropdown que se encuentra en el fichero core.js. Esta función acaba llamando a otras dos funciones AbsLeft y AbsTop, que son el objeto de este post.

Código original de las funciones:

function AbsLeft(obj)
{
    var x=obj.offsetLeft;
    var parent=obj.offsetParent;
    while (parent.tagName !="BODY")
    {
        x+=parent.offsetLeft;
        parent=parent.offsetParent;
    }
    x+=parent.offsetLeft;
    return x;
}

function AbsTop(obj)
{
    var y=obj.offsetTop;
    var parent=obj.offsetParent;
    while (parent.tagName !="BODY")
    {
        y+=parent.offsetTop;
        parent=parent.offsetParent;
    }
    y+=parent.offsetTop;
    return y;
}

Resulta que estas dos funciones lanzan un null reference exception cuando el control lookup esta contenido dentro de un div y ese div contiene un position:relative.

Googleando un poco me he encontrado que este era un error conocido, pero la resolución que daban en un foro de sharepoint no me parecía la correcta, a saber, eliminar el position:relative.

http://social.msdn.microsoft.com/Forums/en-US/sharepointdevelopment/thread/91f91a91-434f-444d-8a96-7823c91f862e

Mi solución final ha sido sobreescribir estas funciones en la master page de mi solución:

function AbsLeft(obj) {
    var x = obj.offsetLeft;
    var parent = obj.offsetParent;

    while (parent != null && parent.tagName != "DIV" && parent.tagName != "BODY") {
        x += parent.offsetLeft;
        parent = parent.offsetParent;
    }

    if (parent != null && parent.tagName != "DIV" && parent != null) x += parent.offsetLeft;

    return x;
}

function AbsTop(obj) {
    var y = obj.offsetTop;
    var parent = obj.offsetParent;

    while (parent != null && parent.tagName != "DIV" && parent.tagName != "BODY") {
        y += parent.offsetTop;
        parent = parent.offsetParent;
    }

    if (parent != null && parent.tagName != "DIV" && parent != null) y += parent.offsetTop;

    return y;
}

Pero aquí no ha acabado todo, estas funciones estan dentro del core.js y el core.js tiene el atributo defer=True, por lo tanto, nunca se llamaban a las funciones que había sobreescrito. Solución: cambiar este attributo añadiendo lo siguiente en la master page.

<SharePoint:ScriptLink language="javascript" name="core.js" Defer="false" runat="server"/>

Para más información sobre el attribute defer, aquí.

Periodic table HTML 5

2010-10-04T08:20:00.001-07:00

Os dejo un enlace a una chuleta donde se muestran los diferentes elementos existentes en HTML 5, en forma de tabla períodica de los elementos. Cada “elemento” contiene links a W3C developer’s guide y a W3Schools.

http://joshduck.com/periodic-table.html

SharePoint Reference Sheet

2010-09-30T03:14:00.001-07:00

Hay que agradecer cuando alguien hace un excelente servicio, como recoger en una misma página tantísimas propiedades muy usadas cuando trabajas con SharePoint y CAML.

http://abstractspaces.wordpress.com/2008/08/01/sharepoint-reference-sheet/

Truquillo CQWP

2010-09-27T09:02:00.001-07:00

Hoy toca un pequeño truquillo que va bien para mostrar los campos que le estan llegando a una Content Query Web Part, así como el valor de estos campos.

La ideas es my simple, modificar el itemstyle.xsl o crear uno custom y añadir el siguiente trozo de xsl:

<xsl:for-each select="@*">
    Name:<xsl:value-of select="name()" />
    Value:<xsl:value-of select"." />
</xsl:for-each>

Una explicación más detallada la podemos encontrar aquí.

Crear una managed metadata column

2010-09-21T06:56:00.001-07:00

Crear una managed metadata column no es tan fácil como seria crear una columna de tipo texto o numérica, etc. El proceso se parece más bien a la manera de crear una columna de tipo lookup.

Este sería el tag Field para una managed metadata column:

<Field Type="TaxonomyFieldTypeMulti"
        DisplayName="MyName"
        List="TaxonomyHiddenList"
        WebId="/"
        ShowField="Term1033"
        Required="FALSE"
        EnforceUniqueValues="FALSE"
        Mult="TRUE"
    Sorteable="FALSE"
        ID="{71A679B9-B7A4-474D-B2EF-D5230C3285AD}"
        StaticName="MyName"
        Name="MyName"
        Group="MyColumns"
        Indexed="FALSE">
  <Default />
  <Customization>
    <ArrayOfProperty>
      <Property>
        <Name>SspId</Name>
        <Value     xmlns:q1="http://www.w3.org/2001/XMLSchema"
            p4:type="q1:string"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance"></Value>
      </Property>
      <Property>
        <Name>GroupId</Name>
      </Property>
      <Property>
        <Name>TermSetId</Name>
        <Value     xmlns:q2="http://www.w3.org/2001/XMLSchema"
            p4:type="q2:string" xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">MyTermSetId</Value>
      </Property>
      <Property>
        <Name>AnchorId</Name>
        <Value     xmlns:q3="http://www.w3.org/2001/XMLSchema"
            p4:type="q3:string"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance"></Value>
      </Property>
      <Property>
        <Name>UserCreated</Name>
        <Value     xmlns:q4="http://www.w3.org/2001/XMLSchema"
            p4:type="q4:boolean"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">false</Value>
      </Property>
      <Property>
        <Name>Open</Name>
        <Value     xmlns:q5="http://www.w3.org/2001/XMLSchema"
            p4:type="q5:boolean"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">false</Value>
      </Property>
      <Property>
        <Name>TextField</Name>
        <Value     xmlns:q6="http://www.w3.org/2001/XMLSchema"
            p4:type="q6:string"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">{AD2D9982-10C9-4BDA-A04C-754EC1DCA9FA}</Value>
      </Property>
      <Property>
        <Name>IsPathRendered</Name>
        <Value     xmlns:q7="http://www.w3.org/2001/XMLSchema"
            p4:type="q7:boolean"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">false</Value>
      </Property>
      <Property>
        <Name>IsKeyword</Name>
        <Value     xmlns:q8="http://www.w3.org/2001/XMLSchema"
            p4:type="q8:boolean"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">false</Value>
      </Property>
      <Property>
        <Name>TargetTemplate</Name>
      </Property>
      <Property>
        <Name>CreateValuesInEditForm</Name>
        <Value     xmlns:q9="http://www.w3.org/2001/XMLSchema"
            p4:type="q9:boolean"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">false</Value>
      </Property>
      <Property>
        <Name>FilterAssemblyStrongName</Name>
        <Value     xmlns:q10="http://www.w3.org/2001/XMLSchema"
            p4:type="q10:string"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">Microsoft.SharePoint.Taxonomy, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c</Value>
      </Property>
      <Property>
        <Name>FilterClassName</Name>
        <Value     xmlns:q11="http://www.w3.org/2001/XMLSchema"
            p4:type="q11:string"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">Microsoft.SharePoint.Taxonomy.TaxonomyField</Value>
      </Property>
      <Property>
        <Name>FilterMethodName</Name>
        <Value     xmlns:q12="http://www.w3.org/2001/XMLSchema"
            p4:type="q12:string"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">GetFilteringHtml</Value>
      </Property>
      <Property>
        <Name>FilterJavascriptProperty</Name>
        <Value     xmlns:q13="http://www.w3.org/2001/XMLSchema"
            p4:type="q13:string"
            xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">FilteringJavascript</Value>
      </Property>
    </ArrayOfProperty>
  </Customization>
</Field>

Además hay que tener en cuenta que al crear una managed metadata column en una lista, también se añade una columna de tipo Note, asociada a esta. Aquí mostramos un ejemplo.

<?xml version="1.0" encoding="utf-8" ?>
<Field Type="Note"
         DisplayName="MyName_0"
         StaticName="MyNameTaxHTField0"
         Name="MyNameTaxHTField0"
         ID="{AD2D9982-10C9-4BDA-A04C-754EC1DCA9FA}"
         ShowInViewForms="FALSE"
         Required="FALSE"
         Hidden="TRUE"
         CanToggleHidden="TRUE" />

Como podéis ver en el primer xml (reference al field de la managed metadata column) hay un conjunto de atributos o elementos que no los podemos saber cuando creamos el xml, sino que lo sabremos en tiempo de ejecución o de provisioning.

Estos elementos serían los siguientes:

WebId

List

SspId

TermSetId

AnchorId

*TextField (esto lo podemos saber si nosotros previamente hemos provisionado el field note que irá asociado a esta columna)

Esto lo hemos solucionando, con un feature receiver que introduce estos atributos (o elementos) en el xml, durante la ejecución, a continuación se muestra algún trozo de esta solución.

Los pasos a seguir serían los siguientes:

// Add Note Field

string fileManagedMetadataNoteField = @"C:\NoteField.xml";

var xmlDocNoteField = XDocument.Load(fileManagedMetadataNoteField);

web.Site.RootWeb.Fields.AddFieldAsXml(xmlDocNoteField);

// Get Managed Metadata Column xml
string filePath = @"C:\ManagedMetadataColumn.xml";

var xmlDoc = XDocument.Load(filePath);

// Modify WebId and ListId
ReplaceWebIdAndListId(xmlDoc, web);
                      
// Modify Customization Element 
ModifyCustomization(web, xmlDoc);

web.Site.RootWeb.Fields.AddFieldAsXml(xmlDoc);

private void ReplaceWebIdAndListId(XDocument doc, SPWeb web)
        {
            var attributeWebId = from f in doc.Elements("Field")
                                 select f.Attribute("WebId");

            var attributeList = from f in doc.Elements("Field")
                                select f.Attribute("List");

            string webUrl = attributeWebId.First().Value;

            string listName = attributeList.First().Value;

            SPWeb referencedWeb = web;
            if (!string.IsNullOrEmpty(webUrl))
            {
                referencedWeb = web.Site.OpenWeb(webUrl);
            }

            attributeWebId.First().SetValue(referencedWeb.ID.ToString());

            SPList referencedList = referencedWeb.Lists[listName];

            attributeList.First().SetValue(referencedList.ID.ToString("B"));

            if (!string.IsNullOrEmpty(webUrl))
            {
                referencedWeb.Dispose();
            }
        }


private void ModifyCustomization(SPWeb web, XDocument doc)
        {
            var properties = from p in doc.Descendants("Property")
                             select p;

            TermStore termStore = null;
            TermSet termSet = null;

            foreach (var property in properties)
            {
                switch (property.Element("Name").Value)
                {
                    case "SspId":
                        termStore = GetDefaultSiteCollectionTermStore(web.Site);
                        property.Element("Value").SetValue(termStore.Id.ToString());
                        break;
                    case "TermSetId":
                        termSet = GetTermSet(termStore, property.Element("Value").Value);
                        property.Element("Value").SetValue(termSet.Id.ToString());
                        break;
                    case "AnchorId":
                        Guid termId = GetTermId(termSet, property.Element("Value").Value);
                        property.Element("Value").SetValue(termId.ToString());
                        break;
                }
            }

        }

        private TermStore GetDefaultSiteCollectionTermStore(SPSite site)
        {
            TaxonomySession session = new TaxonomySession(site);
            return session.DefaultSiteCollectionTermStore;
        }

        private TermSet GetTermSet(TermStore termStore, String termSetName)
        {
            TermSetCollection termSets = termStore.GetTermSets(termSetName, termStore.WorkingLanguage);
            return termSets[0];
        }

        private Guid GetTermId(TermSet termSet, String termNames)
        {
            TermCollection termCollection = termSet.Terms;
            Term term = null;

            if (!string.IsNullOrEmpty(termNames))
            {
                termNames.Split('/').ToList().ForEach(delegate(String termName)
                {
                    term = termCollection[termName];
                    termCollection = term.Terms;
                });
            }

            if (term == null) return Guid.Empty;
            else return term.Id;
        }

Add managed metadata programmatically II

2010-09-21T06:14:00.001-07:00

En el post anterior comentaba el nuevo servicio de managed metadata introducido en MSS 2010, además se explicaba como añadir los términos utilizando la interfaz gráfica. En este nuevo post se va a hacer incapie de como añadir estos metadatos a través del modelo de objetos de MSS 2010.

TaxonomySession session = new TaxonomySession(site);
TermStore termStore = session.DefaultSiteCollectionTermStore;
ImportManager im = termStore.GetImportManager();

var groupToAddTermSet = termStore.CreateGroup("Group name");
groupToAddTermSet.Description = "Group description";

bool allTermsAdded = false;
string errorMessage = string.Empty;

using (TextReader streamReader = new StreamReader(csvPath))
{
    im.ImportTermSet(groupToAddTermSet, streamReader, out allTermsAdded, out errorMessage);
}

termStore.CommitAll();

Cómo podemos ver en este code snippet, le estamos pasando un TextReader a la función de ImportTermSet del objecto de tipo ImportManager. Este TextReader es un stream a un fichero .csv, con el siguiente formato:

"Term Set Name","Term Set Description","LCID","Available for Tagging","Term Description","Level 1 Term","Level 2 Term","Level 3 Term","Level 4 Term","Level 5 Term","Level 6 Term","Level 7 Term"

Add managed metadata programmatically I

2010-09-21T06:05:00.001-07:00

Con MSS 2010 disponemos de un nuevo servicio llamado Managed Metadata Service, con este servicio podemos tener conjuntos de términos, términos y subtérminos que pueden ser utilizados en nuestros sitios como metadatos para nuestros items, de esta forma podemos “etiquetar” de una manera elegante nuestro contenido.

Además, MSS 2010, dispone de un conjunto de utilidades, para navegar por estas managed metadatas.

En este post, se intentará explicar como proveer estos metadatos de forma programatically.

Para más información sobre este servicio podéis consultar la siguiente url:

http://technet.microsoft.com/en-us/library/ee424402.aspx

Un compañero de spenta, Ignasi Tebé, en su blog también comenta esta nueva funcionalidad de manera detallada:

MSS 2010: Servicio de Metadatos Administrados (I)
MSS 2010: Servicio de Metadatos Administrados (II) Content Type Hubs
MSS 2010: Servicio de Metadatos Administrados (III) Ejemplo de uso
MSS 2010: Metadatos administrados: Terminos anidados.
MSS 2010: Metadatos administrados: Importación de estructuras.

Lo que voy a explicar, también se puede hacer directamente a través de la interfaz gráfica de la administración central, a continuación voy a explicar los pasos a seguir para hacerlo a través de la administración central.

Ir a Central Administration
Manage Service Applications
Managed Metadata Services
Add term group

Add term set

Add term

Add sub term

FileNotFoundException al crear un objeto SPSite en Visual Studio 2010

2010-07-28T03:14:00.001-07:00

Hoy me he encontrado con un problema tonto, pero que me ha hecho perder un ratillo de trabajo, y es el siguiente:

He creado una aplicación de consola con Visual Studio 2010 y me he propuesto hacer un simple SPSite site = new SPSite("http://localhost");, me he quedado estupefacto cuando esta instrucción me ha lanzado una excepción del tipo FileNotFoundException. Al principio he pensado que era algo de temas de permisos y tal y he empezado a mirar detalladamente, pero nada todo parecía estar correcto.

Googleando he visto el siguiente hilo: http://social.msdn.microsoft.com/Forums/en-US/sharepointdevelopmentprerelease/thread/ae57f9f1-7a6c-48bc-95ac-2643b76867d8 y efectivamente, !!esto es lo que me pasaba a mi!!

Mi entorno es un entorno de 64bits donde tengo instalado mi granja de MSS 2010. Parece ser que cuando creas un proyecto de console application en visual studio 2010, queda configurado x86 como platform target, simplemente cambiando esto a x64 o Any CPU, funciona correctamente.

Para cambiarlo, hemos de acceder a las propiedades del proyecto y en la pestaña Build cambiar el dropdown de platform target.

Add managed properties programmatically

2010-07-27T02:28:00.000-07:00

Siguiendo con el tema de búsqueda en MSS 2010, nos podemos encontrar que deseamos crear managed properties en tiempo de despliegue, por lo que necesitariamos de alguna forma poder crear managed properties dentro de un feature receiver por ejemplo. Antes de proceder comentar que si bien esto es posible, primero necesitariamos contar con crawled properties ya generadas (por ejemplo de nuestros metadatos), y para ello primero necesitariamos una primera indexación. Una vez comentado esto procederemos a explicar como provisionar estas managed properties.

Lo primero que deberiamos hacer es obtener el searchserviceapplication, para que a partir de este podamos obtener el schema. Esto lo vimos en el post anterior.



SPServiceContext serviceContext = SPServiceContext.GetContext(site);
                   
                    SPServiceApplicationProxy proxy = serviceContext.GetDefaultProxy(typeof(SearchServiceApplicationProxy));
                    SearchServiceApplicationProxy searchAppProxy = proxy as SearchServiceApplicationProxy;

                    SearchServiceApplicationInfo ssai = searchAppProxy.GetSearchServiceApplicationInfo();
                    SearchServiceApplication application =
                      Microsoft.Office.Server.Search.Administration.SearchService.Service.SearchApplications.
                      GetValue(ssai.SearchServiceApplicationId);

                    Schema schema = new Schema(application);

Una vez tenemos esto podemos proceder a crear la managed property, una managed property consta principalmente de un nombre, un tipo de dato (text, integer, datetime), y un mapping con una o más crawled properties.



MappingCollection mappingCollection = new MappingCollection();

                            Microsoft.Office.Server.Search.Administration.ManagedProperty managedProperty = schema.AllManagedProperties.Create("My Managed Property", ManagedDataType.Text);


                            CrawledProperty crawledProperty = GetCrawledProperty(schema, "MyCrawledProperty", ManagedDataType.Text);
                            Mapping mapping = new Mapping(crawledProperty.Propset, crawledProperty.Name, crawledProperty.VariantType, managedProperty.PID);

                            mappingCollection.Add(mapping);


                            managedProperty.SetMappings(mappingCollection);

                            managedProperty.Update();

En este trozo de código podemos ver que hacemos una llamada a un método que nos devuelve una crawled property a partir del schema, un tipo y un nombre. A continuación muestro este método que se encarga de recorrer las crawled properties para obtener la que hemos solicitado.



protected CrawledProperty GetCrawledProperty(Schema schema, string name, ManagedDataType type)
        {
            CrawledProperty result = null;

            foreach (CrawledProperty cproperty in schema.QueryCrawledProperties(string.Empty, 1000, Guid.NewGuid(), string.Empty, true))
            {
                if (cproperty.Name == name)
                {
                    if (cproperty.VariantType == GetVariantType(type))
                    {
                        result = cproperty;
                        break;
                    }
                }
            }

            return result;
        }

        protected int GetVariantType(ManagedDataType type)
        {
            switch (type)
            {
                case ManagedDataType.Text: return 31;
                case ManagedDataType.Decimal: return 5;
                case ManagedDataType.Integer: return 20;
                case ManagedDataType.DateTime: return 64;
                default: return 31;
            }
        }

Bueno, pues esto es todo.

Crear exclude crawling rules programmatically 2010

2010-07-26T04:47:00.001-07:00

Hace unos días comentaba como crear exclude crawling rules en Microsoft Office SharePoint Server 2007 , hoy haremos lo mismo pero ahora con Microsoft SharePoint Server 2010.

1. Obtener el Search Context a partir del SPSite



SPServiceContext serviceContext = SPServiceContext.GetContext(site);

2. Obtenemos el proxy del application service de search (esto es nuevo en 2010, como sabemos ahora desaparecido el shared service provider y tenemos una nueva arquitectura de servicios de aplicación)



SPServiceApplicationProxy proxy = serviceContext.GetDefaultProxy(typeof(SearchServiceApplicationProxy));
                    SearchServiceApplicationProxy searchAppProxy = proxy as SearchServiceApplicationProxy;

3. Obtenemos el objecto de la aplicación de search


SearchServiceApplicationInfo ssai = searchAppProxy.GetSearchServiceApplicationInfo();
                    SearchServiceApplication application =
                      Microsoft.Office.Server.Search.Administration.SearchService.Service.SearchApplications.
                      GetValue(ssai.SearchServiceApplicationId);

4. Obtenemos el Content Source a partir del objecto SerchApplication



Content content = new Content(application);

A partir de aquí es bastante parecido a como trabajabamos con MOSS 2007.

5. Añadir la crawl rule a la colección de crawlrules del content source


CrawlRule crawlRule = content.CrawlRules.Create(CrawlRuleType.ExclusionRule, "http://*/forms/*");

6. Añadir propiedades



crawlRule.FollowComplexUrls = true;

7. Commit la regla en la base de datos



crawlRule.Update();

Instalar sharepoint 2010 con un usuario local sí, pero no

2010-07-13T04:10:00.000-07:00

Hace unos días comentaba que nos podiamos saltar la restricción que imponian desde Microsoft en cuanto a la instalación de un MSS 2010 (Microsoft SharePoint Server 2010) y creación de una granja bajo una cuenta de administrador local. Hoy he de decir que si que es posible, pero nos encontraremos problemas respecto al servicio de búsqueda.

Al intentar configurar el servicio de búsqueda e intentar realizar alguna búsqueda me encontraba con un error del tipo: "Internal server error exception".

Estirando del hilo, surfeando por logs e intentado descrifrar el porqué y cuando se producía este error llegue a ver otro error del tipo:

EnumerateQueryComponents returned an error after enumerating 0 components. Error returned was 0x80131600. cd74d139-25c5-4db5-8c81-a9b9a6e17b1f

07/13/2010 12:39:51.68 w3wp.exe (0x14D0) 0x151C SharePoint Server Search Query Processor e2tq High Source: Microsoft.Office.Server.Search Description: No query components were found for this search application.

Entonces dije, bueno pues voy a crear añadir un query component siguiendo los pasos que se indican aquí.

Al intentar finalizar el último paso me encontré de nuevo con otra barrera. Y con el siguiente error:

Component cbfb21b3-805b-4e3e-9c37-8339756385f9-query-0 of search application 'Search Service Application' has failed to execute transition sequence 'initialize with empty catalog' due to the following error: System.ArgumentException: The SDDL string contains an invalid sid or a sid that cannot be translated.

Por último googleando un poco más y buscando el error que me había dado encontre algunos post que hacian referencia a que no es compatible el servicio de búsqueda y una granja configurada con un usuario local.

http://social.technet.microsoft.com/Forums/en-US/sharepoint2010setup/thread/58902475-396e-42ef-b19d-b06bd4df1ad0

http://tristanwatkins.com/?p=885

Ordenar listas en MOSS 2007

2010-07-08T01:05:00.000-07:00

Si alguna vez nos hemos fijado en una lista de links, esta incorpora una action que nos permite ordenarla. Esta action lo que nos hace es llevarnos a una application page llamada reorder.aspx.

Luego puedes utilizar el campo order para ordenar los items en una content query webpart por ejemplo.

Tirando un poco más del hilo observas que toda item de cualquier lista, contiene ese campo order.

Y aquí es donde surge la pregunta: ¿por qué los señores de Redmond no han incorporado esto a todas las listas y así poder usar esta ordenación en las content query webparts?

Pensando que ha sido un despite, nos decidimos a incorporar esta funcionalidad a todas las listas creando una custom action y añadiendola a todas las listas. Pero cuál fue nuestro despiste que vimos que esta ordenación funcionaba bien excepto para las document libraries.

Haciendo un poquito de debugging y reflectoring vimos que el problema reside en el método que usa para ordenar las listas, este método es un método de la clase SPListItemCollection, el método se llama ReorderItems.

Ahora ya habiamos cruzado ese umbral que es más facil seguir para adelante que volverse para atrás así que nos decidimos a rehacer ese algoritmo de ordenación para que funcionase también con las document libraries.

En definitiva los artefactos que hemos creado han sido:

- Una custom action que se añade a todas las listas y su correspondiente feature
- Un page adapter para capturar el submit de la página reorder.aspx y a partir de aquí llamar a nuestro nuevo algoritmo de reordenación.
- Un extensión method para SPListItemCollection que implementa el algoritmo de ordenación.

Instalar sharepoint 2010 con un usuario local

2010-07-06T06:47:00.000-07:00

Por defecto, el wizard de sharepoint 2010 no nos permite crear una granja a partir de una cuenta de usuario local, pero nos podemos saltar esta protección gracias a un comando de powershell, en concreto: New-SPConfigurationDatabase. Una vez creamos la base de datos de configuración a partir de este comando, podemos arrancar de nuevo el wizard de instalación y ya nos reconocera una base de datos de configuración que habrá sido creada y configurada con nuestro usuario local.

Para más info:

http://www.dev4side.com/community/blog/2010/5/2/how-to-install-sharepoint-2010-with-a-local-account.aspx

¿Hasta cuándo el divide y vencerás?

2010-06-30T11:04:00.000-07:00

En los inicios el aprendizaje se aglutinaba en una sola materia, a saber, LA FILOSOFÍA, aunque ya Aristóteles en su libro FÍSICA, dividía entre matemáticas, física, filosofía primera, etc.

Pero esta división hay ido aumentando con el paso de los años y han aparecido muchísimas materias, entre ellas, historia, geografía, matemáticas, física, química, religión, medicina, etc., y ojo que estoy enumerando las materias troncales, porque de éstas además aparecen otras como, ingeniería de puertos y caminos, ingeniería informática, ingeniería industrial, estadística, y un sinfín que no me voy a poner ahora a enumerar. Si además cogemos una de estas materias vemos que aparecen dentro de ellas innumerables especializaciones, y el lector en este punto se preguntará que a dónde quiero llegar.

Antes de que el lector se desoriente del todo y abandone este blog voy a explicarle, el porqué de esta entrada. Llevo un tiempo fijándome en que la gente se suele especializar en una rama de una materia concreta haciéndose poseedor de un gran conocimiento sobre su especialización, un sabio, se podría decir, y esto no es malo, pero puede llegar a un punto que antepone su conocimiento al resto de los conocimientos, y de alguna forma puede llegar a ningunear los "otros conocimientos". Para intentar clarificar mi posición voy a poner un ejemplo, hoy he estado leyendo un blog sobre una persona experta en usabilidad y arquitectura de la información, en uno de sus posts había escrito que "lo más importante" son las interfaces y el autor podría enumerar muchos argumentos donde le tendríamos que dar la razón de manera inexorable. Pero da la casualidad que si hablas con un administrador de bases de datos, te dirá que "lo más importante" son los datos y de nuevo nos bombardeará con n argumentos, todos dignos de aprobación, y es increíble que si hablásemos con un experto en cualquier otra rama podría ofrecernos un abanico de argumentos exponiéndonos que su rama es "lo más importante". Y aquí es donde empieza a perder la credibilidad el primero, el segundo y el resto de expertos.

Personalmente, creo que nada es "lo más importante" sino que cada cosa es importante en su medida, y lo realmente importante es el todo y el todo visto como una composición de las partes, y digo composición y no agregación, porque no creo que ese todo pueda sobrevivir a una de sus partes. En el campo del desarrollo (que es donde mejor me muevo, debido a mi "especialización"), no puede existir una gran aplicación donde la interfaz sea muy buena, pero por ejemplo la aplicación no sea mantenible, o no puede existir una gran aplicación donde tenga una estructura de datos inmejorable, pero la interfaz sea bochornosa, y así con cada una de sus partes. Dejemos de "dividir" y empecemos a "componer".

Pero bueno en realidad no estoy diciendo nada nuevo, yo creo que esto es sabido por todos, pero no soporto cuando leo a expertos que a propósito o inducidos por su súper yo piensan que su rama o especialización se puede sobreponer a cualquier otra, para mi esto es el claro ejemplo de la definición de hombre masa expuesta por Ortega y Gasset.

"He aquí un precioso ejemplar de este extraño hombre nuevo que he intentado, por una y otra de sus vertientes y haces, definir. He dicho que era una configuración humana sin par en toda la historia. El especialista nos sirve para concretar enérgicamente la especie y hacernos ver todo el radicalismo de su novedad. Porque antes los hombres podían dividirse, sencillamente, en sabios e ignorantes, en más o menos sabios y más o menos ignorantes. Pero el especialista no puede ser subsumido bajo ninguna de esas dos categorías. No es sabio, porque ignora formalmente cuanto no entra en su especialidad; pero tampoco es un ignorante, porque es «un hombre de ciencia» y conoce muy bien su porciúncula de universo. Habremos de decir que es un sabio-ignorante, cosa sobremanera grave, pues significa que es un señor el cual se comportará en todas las cuestiones que ignora no como un ignorante, sino con toda la petulancia de quien en su cuestión especial es un sabio."

José Ortega y Gasset. La rebelión de las masas.

SharePoint css y error javascript al mover webparts

2010-06-15T07:50:00.001-07:00

Hoy me he encontrado con un problemilla al intentar mover (drag and drop) unas webparts de una webpart zone a otra, el problema era bien simple, me ha saltado un error javascript y no me dejaba hacer esta operación.

He debugado el javascript que me estaba dando problemas y resulta que era una función llamada MSOLayout_GetRealOffset. Esta función se encuentra en el fichero \TEMPLATE\LAYOUTS\1033\IE55UP.JS.

Googleando un poco me he encontrado que este problema aparece cuando tu master page contiene algún referencia a estilo con position:relative. Y este era mi caso. Puedes observarlo aquí.

Googleando también he econtrado una solución a este problema aquí. Ésta básicamente reside o bien en quitar el position:relative del css (cosa que no me ha interesado) o bien sobreescribir esta función. Por lo que he optado por esta segunda. Para sobreescribir esta función simplemente has de copiar el siguiente código después del SPWebPartManager.

Updating SPListItem

2010-06-15T06:24:00.000-07:00

En un proyecto en el que estoy trabajando me he encontrado con la necesidad de añadir datos a listas en tiempo de despliegue, a partir de un archivo xml, más o menos como lo que haria la feature listinstance cuando le especificamos un child element data.

Más info...

Una vez leído este fichero xml obtenemos un diccionario key-value, con los fields (keys) de nuestro item y sus valores (value), en nuestro caso ambos serian string.

El problema con el que nos encontramos es que en un SPListItem almacenamos objects, y por lo tanto tendriamos que parsear de alguna forma nuestros strings al tipo de campo que requiere ese field. Para saberlo necesitamos consultar el SPField y este SPField tiene un SPFieldValueType que nos permite determinar el tipo de dato que se almacena en ese campo. Luego añadimos un poco de reflection y utilizamos una función muy interesante que he descubierto, Convert.ChangeType, que permite cambiar de un tipo a otro, y eureka!!! Tenemos un extensión method super útil.

/// 
        /// Update an item using a dictionary with key-value pairs
        /// 

        /// The item
        /// The data collection
        public static void Update(this SPListItem item, Dictionary data)
        {
            bool overwriteVersion = false;

            foreach (String internalFieldName in data.Keys)
            {
                if (item.Fields.Contains(internalFieldName))
                {
                    SPField field = item.Fields.GetFieldByInternalName(internalFieldName);

                    ConstructorInfo constructor = field.FieldValueType.GetConstructor(new Type[] { typeof(string) });

                    if (constructor != null)
                    {
                        item[internalFieldName] = constructor.Invoke(new object[] { data[internalFieldName]});
                    }
                    else
                    {
                        item[internalFieldName] = Convert.ChangeType(data[internalFieldName], field.FieldValueType, CultureInfo.InvariantCulture);
                    }

                    if (field.ReadOnlyField || field.Type == SPFieldType.Computed) overwriteVersion = true;
                }
            }

            if (overwriteVersion) item.UpdateOverwriteVersion();
            else item.Update();
        }

Expresiones regulares

2010-06-09T03:02:00.001-07:00

Hoy en un proyecto he tendio que buscar un texto dentro una cadena que cumpla un determinado patrón, bueno esto como seguramente todos conocen lo podemos solventar utilizando expresiones regulares. La verdad es que nunca me ha gustado batallar con expresiones regulares, pero creo que son de gran utilidad para estos casos.

He estado buscando en la red alguna herramienta que sea de ayuda a la hora de elaborar estas expresiones regulares y he encontrado esta herramienta online que me ha venido muy bien: http://gskinner.com/RegExr/

Supongo que como esta, habrán otras muchas herramientas similares.

Hago también una mención especial a la siguiente web site ya que me ha servido de gran ayuda http://www.radsoftware.com.au/articles/regexlearnsyntax.aspx

SPGridView con generic list

2010-05-17T23:31:00.000-07:00

Yo soy de esas personas que me gusta trabajar con objetos POCO, me gusta la frase que decía Einstein: "Se debe hacer todo tan sencillo como sea posible, pero no más sencillo", no me gustan las estructuras de datos como pueden ser los datatable y otros objetos del estilo.

Parece que trabajar con SharePoint y no usar tipos de datos como datatables es algo imposible, pero no es así, y este post es una pequeña explicación de como usar listas genéricas (http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx) como datasource de un SPGridView y no perder funcionalidades tales como Paging, Filtering, Sorting, etc.

Para ello hacemos uso de LinqDataSource que de una manera muy simple nos permite asignar una lista genérica al datasource y un único método para obtener los datos (a partir del evento Selecting). Esto implica tener habilitadas las extensiones del framework 3.5 en nuestro entorno SharePoint, para ello podemos utilizar la solución de codeplex: http://features.codeplex.com/

Para ello imaginemos que partimos de la siguiente classe Foo:


public class Foo
    {
        public String Field1 { get; set; }
        public String Field2 { get; set; }

        public Foo()
        {
        }

        public Foo(String Field1, String Field2)
        {
            this.Field1 = Field1;
            this.Field2 = Field2;
        }
    }

Para el ejemplo hemos hecho una simple webpart, que renderiza una SPGridView, donde le hemos asignado como datasource un LinqDataSource que contiene nuestra lista genérica de objetos Foo.

Para ello simplemente hemos sobreescrito el método CreateChildControls, en el creamos nuestro SPGridView y le asignamos propiedades como filtering, sorting, paging, etc. y creamos nuestro datasource, añadimos tanto el datasource, como el SPGridView a la coleción de controles de la webpart y hacemos un bind entre la grid y el datasource. Además de esto creamos un event handler para el evento Selecting del DataSource, este evento permitirá obtener los datos.



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using System.Web.UI.WebControls.WebParts;

namespace MyWebparts
{
    public class FooWebpart: System.Web.UI.WebControls.WebParts.WebPart
    {
        #region Variables
        /// 
        /// The grid
        /// 

        private SPGridView myGrid;
        
        /// 
        /// The datasource
        /// 

        private LinqDataSource lqDataSource;

        #endregion

        public FooWebpart()
        {
            this.ExportMode = WebPartExportMode.All;
        }

        protected override void CreateChildControls()
        {

            // Set basic gridview properties
            myGrid = new SPGridView();
            myGrid.ID = "MyGrid";
            myGrid.AutoGenerateColumns = false;

            // Set properties for sorting
            myGrid.AllowSorting = true;

            // Set properties for paging
            myGrid.AllowPaging = true;
            myGrid.PageSize = 25;
            myGrid.PagerSettings.Mode = PagerButtons.NumericFirstLast;

            // Set properties for filtering
            myGrid.AllowFiltering = true;
            myGrid.FilterDataFields = "Field1, Field2";
            myGrid.FilteredDataSourcePropertyName = "Where";
            myGrid.FilteredDataSourcePropertyFormat = "{1} == \"{0}\"";

            // Set columns of the SPGridView
            SPBoundField bfield1 = new SPBoundField();
            bfield1.DataField = "Field1";
            bfield1.HeaderText = "Field1";
            bfield1.SortExpression = "Field1";
            myGrid.Columns.Add(bfield1);

            SPBoundField bfield2 = new SPBoundField();
            bfield2.DataField = "Field2";
            bfield2.HeaderText = "Field2";
            bfield2.SortExpression = "Field2";
            myGrid.Columns.Add(bfield2);

            // Create the linqDatasource 
            lqDataSource = new LinqDataSource();
            lqDataSource.ID = "MyLinqDS";
            lqDataSource.Selecting += new EventHandler(lqDataSource_Selecting);

            // Add datasource to controls collection
            Controls.Add(lqDataSource);

            // Bind SPGridView to linqdatasource
            myGrid.DataSourceID = lqDataSource.ID;
            Controls.Add(myGrid);

            myGrid.PagerTemplate = null;

            base.CreateChildControls();
        }

        void lqDataSource_Selecting(object sender, LinqDataSourceSelectEventArgs e)
        {
            List myGenericList = new List();
            myGenericList.Add(new Foo("uno", "uno"));
            myGenericList.Add(new Foo("dos", "dos"));

            e.Result = myGenericList;
        }
        
    }
}

jquery, ajax, json y sharepoint

2010-05-10T01:13:00.000-07:00

Una forma de implementar una llamada AJAX desde jquery dentro de nuestro entorno MOSS es a través de un httplander.

La llamada jquery va a enviar un conjunto de datos en formato JSON y va a recibir otros datos también en JSON, por lo que tendremos que serializar y deserializar este json en nuestro código servidor.

Vamos a intentar describir todo el procedimiento a partir de un ejemplo, este ejemplo será la implementación de un cascading dropdownlist, primero tendremos un dropdownlist que muestra un conjunto de categorias y al seleccionar una categoria concreta luego otro dropdownlist mostrará las subcategorias presentes para esa categoria. (Típico ejemplo) Todo esto lo haremos dentro de un user control.

1. User control (ascx)

A continuación se muestra el código jquery para hacer la llamad ajax a un web handler llamado FooHandler.ashx.

Veremos que este código JavaScript tiene dos partes una es el bind de la acción change y keyup al dropdownlist categorias y otra es la llamada ajax al web handler.




$(function() {

        // DropDownLists

        var $ddlCategories = $("#<%= DDLCategories.ClientID %>");

        var $ddlSubCategories = $("#DDLSubCategories");



        // Labels

        var $LBSubCategories = $("#<%= LBSubCategories.ClientID %>");

       

        $ddlCategories.focus();

        $ddlCategories.bind("change keyup", function() {

            if ($(this).val() != "0") {



                loadSubCategoriesProducts($("#<%= DDLCategories.ClientID %> option:selected").val());

                $LBSubCategories.fadeIn("slow");

                $ddlSubCategories.fadeIn("slow");



            } else {

                // Hide the others dropdownlists and labels

                $LBSubCategories.fadeOut("slow");

                $ddlSubCategories.fadeOut("slow");

            }

        });

      

    });



    function loadSubCategoriesProducts(selectedItem) {

        $.ajax({

            type: "POST",

            url: '_layouts/Handlers/FooHandler.ashx',

            data: "{ method: 'GetSubCategories', ID: '" + selectedItem + "'}",

            contentType: "application/json; charset=utf-8",

            dataType: "json",

            async: true,

            success: function(data) {

                $("#DDLSubCategories").children().remove();

                for (var i = 0; i < val =" data[i].Id;" text =" data[i].Title;">").val(val).html(text));

                }

            }

        });

    }

1.1 User control (code behind)

Nuestro user control en el code behind sólo tendrá la carga inicial de las categorias en el primer dropdown:

 



public class FOOCodeBehind: UserControl

    {

        

        #region Protected Fields



        protected DropDownList DDLCategories;

        

        #endregion



        #region Overriden Methods



        protected override void CreateChildControls()

        {



            base.CreateChildControls();



            DDLCategories.DataSource = GetCategories();

            DDLCategories.DataTextField = "Title";

            DDLCategories.DataValueField = "Id";

            DDLCategories.DataBind();



        }



        #endregion



        #region Private Methods



        private List GetCategories()

        {

            var categories = new List();



            categories.Add(new Category("1", "Category1"));

            categories.Add(new Category("2", "Category2"));

            categories.Add(new Category("3", "Category3"));

            categories.Add(new Category("4", "Category4"));



            return categories;

        }



        #endregion

    }

2. Ahora toca definir el handler que hemos llamado FooHandler.ashx. Como podéis observar en la llamada Ajax, esto en realidad es una página (.ashx) que esta dentro del folder Handlers que a la vez esta dentro del folder layouts del folder 12 de MOSS.

Esta página simplemente contendrá lo siguiente:

2.1 Code Behind Web Handler

Aquí necesitaremos implementar nuestro handler, este será una clase que derive de IHttpHandler e implemente el método ProcessRequest.
Este método comprobará si el content type recibido es de tipo json, y entonces deserializará lo que hemos recibido en el inputstream a un diccionario key, value, donde las claves son strings y los values objects.

Para eso hemos creado un extensión de object que serializa y deserializa json. Esta extensión en el código lo tenemos cuando hemos añadido la referencia Core.JSON, esta es una referencia propia, pero tranquilos que también añado el código:

 



using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Web;

using Core.JSON;



namespace MyHandlers

{

    public class FooHandler: IHttpHandler

    {



        #region IHttpHandler Members



        bool IHttpHandler.IsReusable

        {

            get { return true; }

        }



        void IHttpHandler.ProcessRequest(HttpContext context)

        {

            if (context.Request.ContentType.Contains("json"))

            {

                var inputStream = new System.IO.StreamReader(context.Request.InputStream);

                var inputJson = inputStream.ReadToEnd();



                var collectionJson = inputJson.ToObject>();



                context.Response.Clear();

                context.Response.ContentType = "application/json";



                if (!string.IsNullOrEmpty(collectionJson["method"].ToString()))

                {

                    var json = string.Empty;



                    switch (collectionJson["method"].ToString())

                    {

                        case "GetSubCategories":

                            json = GetSubCategories(collectionJson["id"].ToString());

                            break;

                    }



                    context.Response.Write(json);

                }

            }



        }



        #endregion



        #region Private Methods



        private string GetSubCategories(String id)

        {

            var subcategories = new List();



            subcategories.Add(new SubCategory("1", "SubCategory 1"));

            subcategories.Add(new SubCategory("2", "SubCategory 2"));

            subcategories.Add(new SubCategory("3", "SubCategory 3"));

            subcategories.Add(new SubCategory("4", "SubCategory 4"));



            return subcategories.ToJSON();

        }

    }

}

3. Extension methods para serializar/deserializar JSON

 



using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Web.Script.Serialization;



namespace Core.JSON

{

    public static class ojectExtensionJSON

    {

        public static string ToJSON(this object obj)

        {

            JavaScriptSerializer serializer = new JavaScriptSerializer();

            return serializer.Serialize(obj);

        }



        public static string ToJSON(this object obj, int recursionLimit)

        {

            JavaScriptSerializer serializer = new JavaScriptSerializer();

            serializer.RecursionLimit = recursionLimit;

            return serializer.Serialize(obj);

        }



        public static T ToObject(this string json)

        {

            JavaScriptSerializer serializer = new JavaScriptSerializer();

            return serializer.Deserialize(json);

        }

    }

}

Popup para seleccionar lista

2010-04-29T02:15:00.000-07:00

Alguna vez nos hemos preguntado como mostrar una propiedad que nos permita seleccionar una lista dentro de la site collection, de la misma forma que hace la content query webpart "CQWP". El siguiente post intentará mostrar como hacer esto:

Lo primero que se ha hecho es crear un editor part que carga un user control, este user control tendría que tener un textbox para añadir la url de la lista, y un botón que llame a un javascript, en nuestro caso "launchpicker" que nos permita mostrar el popup.



var lastSelectedListSmtPickerId = '';

    function launchPicker(id) {
        
        if (!document.getElementById) return;

        var listurlfield = document.getElementById(id);
        var defaulturl = '<%=SPContext.Current.Web.ServerRelativeUrl %>';

        var url = defaulturl;

        if (listurlfield != null && listurlfield.value != '') {
            url = listurlfield.value.substring(0, listurlfield.value.lastIndexOf('/'));
        }

        var callback = function(results) {
            if (results == null || results == undefined || results[1] == null || results[2] == null) return;

            lastSelectedListSmtPickerId = results[0];
            var listUrl = '/';
            if (results[1].charAt(0) == '/') results[1] = results[1].substring(1);
            listUrl = listUrl + results[1];
            if (listUrl.substring(listUrl.length - 1) != '/') listUrl = listUrl + '/';
            if (results[2].charAt(0) == '/') results[2] = results[2].substring(1);
            listUrl = listUrl + results[2];
            listurlfield.value = listUrl;
        };

        LaunchPickerTreeDialog('CbqPickerSelectListTitle', 'CbqPickerSelectListTitle', 'listsOnly', '', url, lastSelectedListSmtPickerId, '', '', '/_layouts/images/smt_icon.gif', '', callback);
    }

Luego nuestra editor part tendría que cargar dinámicamente este user control que hemos creado, además ha de implementar los métodos Synchanges, de donde obtendremos el valor actual configurado en la webpart y el método ApplyChanges donde haremos un set de la propiedad de la webpart.



public class FooEditorPart: EditorPart
    {
        #region Fields

        protected GetListUserControl editorUC;

        #endregion
        
        #region Constructor

        public FooEditorPart(string webpartid)
        {
            this.ID = "FooEditorPart" + webpartid;
            this.Title = "Link Editor";
        }

        #endregion

        #region Overriden Methods

        /// 
        /// Create the controls
        /// 

        protected override void CreateChildControls()
        {
            base.CreateChildControls();

            try
            {
                editorUC = (GetListUserControl)this.Page.LoadControl("~/_CONTROLTEMPLATES/GetListUserControl.ascx");

                Controls.Add(editorUC);
            }
            catch (Exception ex)
            {
                LogHelper(ex)
            }
        }

        /// 
        /// Get the value from webpart
        /// 

        public override void SyncChanges()
        {
            EnsureChildControls();

            WebpartFoo webPart = WebPartToEdit as WebpartFoo;
            if (webPart != null)
            {
                editorUC.TbListUrl.Text = webPart.LinkList;
            }
        }

        /// 
        /// ApplyChanges in webpart
        /// 

        /// 
        public override bool ApplyChanges()
        {
            EnsureChildControls();
            WebpartFoo webPart = WebPartToEdit as WebpartFoo;
            if (webPart != null)
            {
                webPart.LinkList= editorUC.TbListUrl.Text;
            }
            return true;
        }

        #endregion
    }

Por último nuestra webpart tendrá que tener una propiedad string con el atributo WebBrowsable(false), y tendrá que implementar la interfaz IWebEditable, esto nos obliga a implementar el método CreateEditorParts, donde añadiremos nuestro nuevo editor part, y la propiedad WebBrowsableObject.



public class WebpartFoo: WebPart, IWebEditable
    {
        #region Properties

        [Personalizable(PersonalizationScope.Shared)]
        [WebBrowsable(false)]
        public string LinkList { get; set; }

        #endregion

        #region Default Constructor
        public WebpartFoo()
        {
            ExportMode = WebPartExportMode.All;
        }

        #endregion

        
        #region IWebEditable Members

        EditorPartCollection IWebEditable.CreateEditorParts()
        {
            List editors = new List();

            // Add the base editor parts
            EditorPartCollection baseParts = base.CreateEditorParts();
            foreach (EditorPart basePart in baseParts)
                editors.Add(basePart);

            editors.Add(new FooEditorPart(this.ID));
            return new EditorPartCollection(editors);
        }

        object IWebEditable.WebBrowsableObject
        {
            get { return this; }
        }

        #endregion

  }

A partir de aquí ya podriamos usar nuestra lista seleccionada, cómo curiosidad, remarcar que el popup al obtener la url de la lista no le añade el /Lists ni la url correcta de la lista, sino que le añade el title de la lista, por lo que para poder desde codigo obtener la lista podriamos hacer algo como lo siguiente:



private void foo()
        {
            if (!String.IsNullOrEmpty(LinkList))
            {
                string UrlWeb = LinkList.Substring(0, LinkList.LastIndexOf("/"));
                string ListName = LinkList.Substring(LinkList.LastIndexOf("/") + 1);

                using (SPWeb web = SPContext.Current.Site.OpenWeb(UrlWeb))
                {
                    SPList list = web.Lists[ListName];

                    // TODO
                }
            }
        }

Crear exclude crawling rules programmatically

2010-04-16T00:23:00.000-07:00

Añadir "exclude crawling rules" es muy sencillo.

Los pasos a seguir serían los siguiente:

1. Obtener el Search Context

//get the site SSP's search server instance
SearchContext searchContext = SearchContext.GetContext(site);

2. Obtener el Content Source

//get the content source for the search server
Content sspContent = new Content(searchContext);

3. Añadir la crawl rule a la colección de crawlrules del content source

string rule = "http://*/forms/*";
//create the crawl rule, setting the type of crawl rule and the crawl rule string
CrawlRule crawlRule = sspContent.CrawlRules.Create(CrawlRuleType.ExclusionRule, rule);

4. Añadir propiedades

crawlRule.FollowComplexUrls = true;

5. Commit la regla en la base de datos

//commit the rule in the database
crawlRule.Update();

Esta información ha sido extraída del siguiente blog:

http://blog.richfinn.net/blog/2008/06/19/CreateSearchCrawlRulesProgrammatically.aspx

FORO DE ARQUITECTOS BARCELONA

2010-04-13T01:12:00.000-07:00

El próximo 13 de Mayo se hará en Barcelona un FORO DE ARQUITECTOS, donde entre otras cosas se presentará la propuesta Arquitectura DDD N-Layer.

Podéis registraros en siguiente link:

http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032446174&Culture=es-ES

SharePoint fields objects

2010-04-08T23:49:00.000-07:00

A continuación se muestra una tabla donde se definen los diferentes nombres de classe para cada tipo de datos de MOSS 2007, esta información ha sido extraida del siguiente blog:

http://www.tonstegeman.com/Blog/Lists/Posts/Post.aspx?List=70640fe5%2D28d9%2D464f%2Db1c9%2D91e07c8f7e47&ID=32

Evitar pop-up warning al editar un item

2010-04-07T07:46:00.000-07:00

Hoy me he encontrado un problema al editar un item, este item tiene un custom field que hace postback, y al hacerlo me aparece el siguiente mensaje:

Si pulsamos cancelar no hay problema, pero al pulsar OK, esto implica que aparezca el siguiente error al intentar luego guardar el item.

La solución la he extraido de una respuesta de un conocido amigo (Edin Kapic) en un foro. Añado enlace al post original: http://social.msdn.microsoft.com/Forums/es-ES/mossdeves/thread/3d46ab13-b821-4f31-939a-678eb30be81f

El problema viene dado que cuando tenemos la feature de publishing activada, se añade un javascript que nos controla cuando estamos en edición y nos pregunta antes de salir de la página, si queremos guardar los cambios.

La solución es desactivar la feature de publishing o añadir un tag script en nuestra página donde ponga la variable g_bWarnBeforeLeave a false, ya que es esta variable por la que pregunta el javascript antes mencionado.

XSD2Code Generator

2010-03-15T04:50:00.000-07:00

XSD2Code Generator es una herramienta que nos permite generar business class a partir de schemas xml (ficheros .xsd). Es una evolución de la herramienta xsd.exe que viene con nuestra instalación de visual studio.

Cómo características a resaltar respecto a la herramienta xsd.exe es que soporta generics y custom collections. Cuando generamos classes con xsd, xsd.exe nos generaba clases con atributos del tipo array, mientras que xsd2code nos genera clases con propiedades del tipo List. Además se nos añade como un Addin para visual studio 2008.

Un ejemplo bien secillo de su uso sería el siguiente:

1. Obtener o generar un xml para el que queremos generar la classe que lo serialize / deserialize.

2. Generar el schema (fichero .xsd) Menú XML > Create Schema, se nos generará un archivo cómo el siguiente.

3. Por último hacemos botón derecho sobre el fichero .xsd desde el solution explorer y pulsamos la opción Run xsd2code generation. Se nos abrirá una ventana modal donde podemos elegir las propiedades para la generación del código, como por ejemplo el lenguaje, si queremos una clase base, etc. A continuación muestro un trozo de código generado con esta herramienta.


using System;
using System.Diagnostics;
using System.Xml.Serialization;
using System.Collections;
using System.Xml.Schema;
using System.ComponentModel;
using System.Collections.Generic;

namespace prueba {
      
    public partial class FooClass {
      
        private List fooSubClassesField;
      
        private string attribute1Field;
      
        public FooClass() {
            this.fooSubClassesField = new List();
        }
      
        [System.Xml.Serialization.XmlArrayItemAttribute("FooSubClass", IsNullable=false)]
        public List FooSubClasses {
            get {
                return this.fooSubClassesField;
            }
            set {
                this.fooSubClassesField = value;
            }
        }
      
        public string Attribute1 {
            get {
                return this.attribute1Field;
            }
            set {
                this.attribute1Field = value;
            }
        }
    }
  
    public partial class FooClassFooSubClass {
      
        private string field1Field;
      
        private string field2Field;
      
        public string field1 {
            get {
                return this.field1Field;
            }
            set {
                this.field1Field = value;
            }
        }
      
        public string field2 {
            get {
                return this.field2Field;
            }
            set {
                this.field2Field = value;
            }
        }
    }
}

ListInstance (FeatureId y TemplateType)

2010-03-09T06:41:00.000-08:00

Cuando estamos creando una feature para provisionar una lista a nuestra solución MOSS (Element ListInstance), aparecen dos campos de suma importancia:

FeatureId: Text obligatorio. Especifica el identificador GUID de la característica. Si no se especifica un GUID de característica, Windows SharePoint Services usa el identificador de la característica predeterminada; en otras palabras, el que contiene el elemento ListInstance. Si la plantilla de lista para la instancia de lista se encuentra dentro de otra característica, se debe especificar el identificador de dicha característica mediante el atributo FeatureId.

TemplateType: Integer obligatorio. Devuelve el identificador del entero de la plantilla de lista que se va a usar.

La siguiente tabla muestra las listas disponibles en MOSS (algunas también en WSS) , sus Type IDS y sus GUIDS.

Type ID	Description	GUID of feature
100	Generic list	00bfea71-de22-43b2-a848-c05709900100
101	Document library	00BFEA71-E717-4E80-AA17-D0C71B360101
102	Survey	00BFEA71-EB8A-40B1-80C7-506BE7590102
103	Links list	00BFEA71-2062-426C-90BF-714C59600103
104	Announcements list	00BFEA71-D1CE-42de-9C63-A44004CE0104
105	Contacts list	00BFEA71-7E6D-4186-9BA8-C047AC750105
106	Events list	00BFEA71-EC85-4903-972D-EBE475780106
107	Tasks list	00BFEA71-A83E-497E-9BA0-7A5C597D0107
108	Discussion board	00BFEA71-6A49-43FA-B535-D15C05500108
109	Picture library	00BFEA71-52D4-45B3-B544-B1C71B620109
110	Data sources	00BFEA71-F381-423D-B9D1-DA7A54C50110
111	Site template gallery	SYSTEM
113	Web Part gallery	SYSTEM
114	List template gallery	SYSTEM
115	XML Form library	00BFEA71-1E1D-4562-B56A-F05371BB0115
116	Masterpage and page layouts library	SYSTEM
117	No-code workflow library	00BFEA71-F600-43F6-A895-40C0DE7B0117
118	Workflow process list	00BFEA71-2D77-4A75-9FCA-76516689E21A
119	Web page library	00BFEA71-C796-4402-9F2F-0EB9A6E71B18
120	Custom grid for a list	00BFEA71-3A1D-41D3-A0EE-651D11570120
130	Data connection library	00BFEA71-DBD7-4F72-B8CB-DA7AC0440130
140	Workflow history list	00BFEA71-4EA5-48D4-A4AD-305CF7030140
150	Gantt tasks list	00BFEA71-513D-4CA0-96C2-6A47775C0119
1100	Issue tracking	00BFEA71-5932-4F9C-AD71-1557E5751100

IISAPP.VBS en Windows Server 2008

2010-03-09T06:18:00.000-08:00

En Windows 2003 Server y IIS 6 disponiamos de un magnifico script para determinar el ID de un worker process, iisapp.vbs, de esta forma poder atacharlo en Visual Studio para debugar.

Para más información ver:

http://www.microsoft.com/technet/prodtechnol/WindowsServer2003/Library/IIS/b8721f32-696b-4439-9140-7061933afa4b.mspx?mfr=true

En Windows Server 2008 y IIS 7 esta utilidad ya no existe, pero tenemos otros comandos que nos ofrecen la misma funcionalidad:

%windir%\system32\inetsrv\appcmd.exe list wp

MOSS 2007: Cómo customizar la página de creación de una lista

2010-03-01T23:47:00.000-08:00

Es posible modificar la página de creación de una lista, es decir, la página donde especificamos nombre de la lista, descripción, etc.

Pero la idea, no seria modificar esta página directamente, pues pertenece al core de moss.

Lo ideal seria crear una nueva definición de lista, y a esta nueva definición de lista indicarle nuestra propia página de creación, dónde podamos especificar los datos que nos sean de utilidad.

Para ello disponemos de un atributo, NewPage, en el listtemplate:







Name="indexlist"

Type="10010"

BaseType="0"

OnQuickLaunch="TRUE"

SecurityBits="11"

Sequence="410"

DisplayName="Index List"

Description="F4EDocs index list template"

NewPage="F4E.F4EDocs/NewIndexList.aspx"

Image="/_layouts/images/itgen.gif"/>

Luego tendremos que crear nuestra application page, podriamos partir de la existente en /_layouts/new.aspx, y añadir el comportamiento que deseemos, esta application page tendría que derivar de Microsoft.SharePoint.ApplicationPages.LayoutsPageBase.

Un ejemplo de esto se explica en:

http://furuknap.blogspot.com/2009/01/consuming-rss-or-atom-feed-in.html

New challenge

2010-02-22T09:08:00.000-08:00

Hoy comienzo un nuevo reto profesional, este reto se llama Spenta Consulting, donde he de decir que desde un primer momento me he sentido como en casa.

Entre mis compañeros se respira una gran profesionalidad de la que espero formar parte en cuanto tenga oportunidad, es decir en cuanto acabe de aterrizar. Espero estar a la altura de todos ellos.

Custom ASP.net Web Application in MOSS

2009-08-27T01:40:00.001-07:00

Actualmente para un proyecto hemos decidido crear una aplicación web dentro del directorio _layouts de MOSS 2007, nos encontrabamos con el error siguiente al cargar una master page que esta ubicada en el mismo directorio _layouts:

The referenced file '/TEMPLATE/LAYOUTS/MyWebApp/MyMasterPage.master' is not allowed on this page. at System.Web.UI.TemplateParser.ProcessError(String message) at System.Web.UI.BaseTemplateParser.GetReferencedType(VirtualPath virtualPath, Boolean allowNoCompile) at System.Web.UI.PageParser.ProcessMainDirectiveAttribute(String deviceName, String name, String value, IDictionary parseData) at System.Web.UI.TemplateParser.ProcessMainDirective(IDictionary mainDirective)

Para solucionarlo hemos hecho lo siguiente:

- Modificar el atributo MasterPageFile de la directiva Page de nuestra custom .aspx indicandole la página maestra application.master.



MasterPageFile="~/_layouts/application.master"

- Luego en el fichero .cs (Code Behind) hemos asignado nuestra página maestra en el evento PreInit



protected void Page_PreInit(object sender, EventArgs e)
{
this.MasterPageFile = "~/_layouts/MyWebApp/MyMasterPage.master";
}

Permisos EventLog

2009-05-28T04:09:00.000-07:00

Para permitir a los usuarios impersonados escribir en el eventlog, es necesario modificar una clave del registro de windows, en concreto:

HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Eventlog\MyLogName\CustomSD

Para permitir a los usuarios autenticados permisos de escritura se ha de aññadir el siguiente permiso:
(A;;0x0002;;;AU)

Para permitir a un usuario específico permiso de escritura debermos especificar su SID:
(A;;0x0002;;;SID-OF-USER-ACCOUNT)

CopyUtil.aspx - Una gran Application Page

2009-04-21T07:52:00.000-07:00

CopyUtil.aspx es una application page dentro de MOSS 2007 que nos permite navegar a un item sabiendo el id del item, el id de la lista, el id de la site y el id de la site collection, esto nos ahorra mucho trabajo a la hora de componer urls hacia los items.

Para ir a un item concreto tenemos que construir la siguiente URL:

http://server/_layouts/CopyUtil.aspx?Use=id&Action=dispform&ItemId=X&ListId=X&WebId=X&SiteId=X

sustituyendo las X por los ID's correspondientes. El parámetro "action" puede ser sustituido por dispform o editform, para que nos rediriga a la URL que nos muestra el item o para que nos rediriga a la URL para editar el item.

Error wizard sharepoint

2009-02-12T07:54:00.000-08:00

Tras instalar el SP1 de MOSS 2007 en una granja de servidores e intentar pasar el wizard de configuración me he encontrado con la siguiente excepción:

Microsoft.SharePoint.Administration.SPUpdatedConcurrencyException was thrown. Additional exception information: An update conflict has occurred, and you must re-try this action. The object DiagnosticsService Parent=SPFarm Name=SharePoint_Config is being updated by Domain\User, in the w3wp process, on machine SERVER. View the tracing log for more information about the conflict. Microsoft.SharePoint.Administration.SPUpdatedConcurrencyException: An update conflict has occurred, and you must re-try this action. The object DiagnosticsService Parent=SPFarm Name=SharePoint_Config is being updated by Domain\User, in the w3wp process, on machine SERVER. View the tracing log for more information about the conflict.

Al parecer esto sucede cuando hay un objeto bloqueado a nivel de SPFarm. Para solventar este problema hay que limpiar la cache de configuración de Windows SharePoint Services.

http://support.microsoft.com/kb/944267/en-us/

¿Y donde se encuentra esta cache?

Esta caché se encuentra en:

C:\Documents and Settings\All Users\Application Data\Microsoft\SharePoint\Config\[GUID]

La solución pasa por borrar todos los xml de esta carpeta [CUIDADO NO BORRAR EL ARCHIVO cache.ini], luego se ha de editar el archivo cache.ini y poner un 1 y guardar.

http://support.microsoft.com/kb/939308/en-us/

Copiar items y folders entre DocumentLibrary manteniendo sus campos

2009-02-05T04:04:00.000-08:00

Me he encontrado en un proyecto en que unas librerías de sharepoint que fueron migradas de 2003 daban un error al intentar mover elementos usando el sitemanger. Vimos que esto no pasaba en las otras librerías por lo que tuvimos que hacer un script para mover documentos y folders de una librería a otra, eso sí manteniendo todos sus metadatos, aquí algunos de los pasos que hemos seguido:

1. Igualar los campos de las bibliotecas:


public static void IgualarCampos(SPDocumentLibrary origen, SPDocumentLibrary destino)
{
if (origen == null  destino == null) throw new ArgumentException("Las bibliotecas destino y origen no pueden ser nulas");
try
{
List listaCamposDestino = new List();
foreach (SPField field in destino.Fields)
{
listaCamposDestino.Add(field);
}
// Compara con origen y crea las necesarias en destino
foreach (SPField field in origen.Fields)
{
SPField campoBuscado = listaCamposDestino.Find(delegate(SPField campo)
{
return campo.Id == field.Id;
});
// Si no existe lo añadimos
if (campoBuscado == null )
{
// Se crea campo en lista destino.
destino.Fields.Add(field);
}
}
}
catch (Exception ex)
{
throw ex;
}
}

2. Funciones recursivas para recorrer todos los folders y crearlos en el destino así como los items por folder:


public static void CopyFoldersAndItems(SPDocumentLibrary origen, SPDocumentLibrary destino)
{
if (origen == null  destino == null) throw new ArgumentException("Las bibliotecas destino y origen no pueden ser nulas");
try
{
string urldestinofolders = destino.RootFolder.ServerRelativeUrl.ToString();
SPFolderCollection foldersdestino = destino.ParentWeb.GetFolder(urldestinofolders).SubFolders;
string urlorigenfolders = origen.RootFolder.ServerRelativeUrl.ToString();
SPFolderCollection foldersorigen = origen.ParentWeb.GetFolder(urlorigenfolders).SubFolders;
foreach (SPFile file in origen.RootFolder.Files)
{
SPFile newFile = destino.RootFolder.Files.Add(file.Name, file.OpenBinary(), file.Author, file.ModifiedBy, file.TimeCreated, file.TimeLastModified);
SPListItem newItem = newFile.Item;
foreach (SPField f in file.Item.Fields)
{
if (!f.ReadOnlyField) newItem[f.InternalName] = file.Item[f.InternalName];
}
newItem["Modificado"] = file.TimeLastModified;
newItem["Creado"] = file.TimeCreated;
newItem.UpdateOverwriteVersion();
}
CopyFoldersAndItems(foldersorigen, foldersdestino);
}
catch (Exception ex)
{
throw ex;
}
}
public static void CopyFoldersAndItems(SPFolderCollection origen, SPFolderCollection destino)
{
try
{
foreach (SPFolder folder in origen)
{
if (folder.Name != "Forms")
{
SPFolder nuevo = destino.Add(folder.Name);
foreach (SPFile file in folder.Files)
{
SPFile newFile = nuevo.Files.Add(file.Name, file.OpenBinary(), file.Author, file.ModifiedBy, file.TimeCreated, file.TimeLastModified);
SPListItem newItem = newFile.Item;
foreach (SPField f in file.Item.Fields)
{
if(!f.ReadOnlyField) newItem[f.InternalName] = file.Item[f.InternalName];
}
newItem["Modificado"] = file.TimeLastModified;
newItem["Creado"] = file.TimeCreated;
newItem.UpdateOverwriteVersion();
}
if (folder.SubFolders.Count > 0) CopyFoldersAndItems(folder.SubFolders, nuevo.SubFolders);
}
}
}
catch (Exception ex)
{
throw ex;
}
}

Obtener webparts de una página (MOSS 2007)

2009-02-02T08:59:00.000-08:00

Aquí tenemos un ejemplo para obtener las webparts de una página de publicación,
una vez tenemos el tipo de la webpart podemos hacer un casting y acceder a sus propiedades para consultarlas y/o modificarlas.


using System;
using System.Collections.Generic;
using System.Text;
using System.Web.UI.WebControls.WebParts;

using Microsoft.SharePoint;
using Microsoft.SharePoint.WebPartPages;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            using(SPSite siteCollection = new SPSite("http://localhost:44236"))
            {
                using(SPWeb site = siteCollection.OpenWeb())
                {
                    using (SPLimitedWebPartManager manager = site.GetLimitedWebPartManager("Paginas/default.aspx", PersonalizationScope.Shared))
                    {
                        foreach (System.Web.UI.WebControls.WebParts.WebPart wp in manager.WebParts)
                        {
                            Console.WriteLine(wp.GetType().ToString());
                        }
                    }
                }
            }

            Console.ReadLine();
        }
    }
}

Añadir link abra el panel de control en una webpart

2009-02-02T05:55:00.000-08:00

Si nuestra webpart necesita tener configuradas ciertas propiedades podemos mostrar un link que abra el panel de control (toolpane) hasta que estas propiedades no estén configuradas. Para ello tenemos que distinguir entre dos casos: webparts que derivan de Microsoft.SharePoint.WebParts.Webpart o webparts que derivan de System.Web.UI.WebControls.WebParts.Webpart.

En el primer caso tenemos una función, ToolPane.GetShowExtensibleToolPaneEvent, que pasándole el id de nuestra webpart nos devuelve un string con la llamada javascritpt que queremos realizar, por lo que el código quedaría algo como:


public class WPPrueba : Microsoft.SharePoint.WebPartPages.WebPart
{
#region Variables
private string _propiedad;
#endregion
#region Propieades
[Browsable(true),
Category("Mis Propiedades"),
DefaultValue(""),
WebPartStorage(Storage.Shared),
FriendlyName("Propiedad"),
Description("Propiedad.")]
public string Propiedad
{
get { return _propiedad; }
set { _propiedad = value; }
}
protected override void Render(HtmlTextWriter writer)
{
base.Render(writer);
try
{
if (Propiedad == null Propiedad == "")
{
string funcionJavaScript = ToolPane.GetShowExtensibleToolPaneEvent(this.ID);
string html = "abra el panel de herramientas";
writer.Write(html);
}
else
{
writer.Write("hello world");
}
}
catch(Exception ex)
{
}
}
#endregion
}

En el segundo caso no podemos hacer esto por lo que añadiremos el código javascript a mano:



string html = " abra el panel de herramientas";

MCPD Web Developer

2009-01-31T07:18:00.000-08:00

El próximo viernes rendiré el examen que me puede acreditar como MCPD (Microsoft Certified Professional Developer): Web Developer. Este exámen es el 70-547: PRO: Designing and Developing Web Applications by Using the Microsoft .NET Framework.

Para preparar esta certificación he estado leyendo el libro: MCPD Self-Paced Training Trainink Kit (Exam 70-547), este libro contiene los siguientes capítulos:

Chapter 1: Application Requirements and Design
Chapter 2: Decompose Specifications for Developers
Chapter 3: Design Evaluation
Chapter 4: Creating a User Interface
Chapter 5: Creating and Choosing Controls
Chapter 6: Data Validation
Chapter 7: Delivering Multimedia
Chapter 8: Component Design
Chapter 9: Component Development
Chapter 10: Reusable Software Components
Chapter 11: Application Logic Layer
Chapter 12: Logging and Monitoring
Chapter 13: Application Configuration
Chapter 14: Define and Evaluate a Testing Strategy
Chapter 15: Creating Development Tests
Chapter 16: Deploying an Application
Chapter 17: Supporting an Application

Para más información:

http://www.microsoft.com/learning/mcp/mcpd/webdev/default.mspx

Logger to SharePoint Logs

2009-01-30T04:13:00.000-08:00

Hola actualmente hemos creada una pequeña utilidad que nos permite serializar los logs utilizando el mismo sistema que utilidad Windows SharePoint Services. Lo que hemos hecho es crear una clase TraceProvider igual que nos indican en las MSDN:

http://msdn.microsoft.com/en-us/library/aa979522.aspx

Luego hemos creado una classe estática logger con un conjunto de métodos estáticos que nos facilitan a la hora de guardar los logs.

public static class Logger
{
public static void LogUnassigned(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.Unassigned, ProductName, Title, Message);
}
public static void LogCriticalEvent(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.CriticalEvent, ProductName, Title, Message);
}
public static void LogWarningEvent(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.WarningEvent, ProductName, Title, Message);
}
public static void LogInformationEvent(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.InformationEvent, ProductName, Title, Message);
}
public static void LogException(Exception e)
{
Log(TraceProvider.TraceSeverity.Exception, e.Source, e.TargetSite.ToString(), e.ToString());
}
public static void LogAssert(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.Assert, ProductName, Title, Message);
}
public static void LogUnexpected(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.Unexpected, ProductName, Title, Message);
}
public static void LogMonitorable(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.Monitorable, ProductName, Title, Message);
}
public static void LogHigh(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.High, ProductName, Title, Message);
}

public static void LogMedium(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.Medium, ProductName, Title, Message);
}
public static void LogVerbose(string ProductName, string Title, string Message)
{
Log(TraceProvider.TraceSeverity.Verbose, ProductName, Title, Message);
}
private static void Log(TraceProvider.TraceSeverity type, string ProductName, string Title, string Message)
{
TraceProvider.RegisterTraceProvider();
TraceProvider.WriteTrace(0, type, Guid.NewGuid(), ProductName, ProductName, Title, Message);
TraceProvider.UnregisterTraceProvider();
}
}

Navegación fuera de contexto en sharepoint (moss 2007)

2009-01-29T11:40:00.000-08:00

Una forma de recorrer una jerarquia de sites de publicación en MOSS 2007 desde fuera del contexto web (es decir desde una aplicación de consola, aplicación windows, etc. ) seria utilizando las propiedades CurrentNavigationNodes y GlobalNavigationNodes de la clase PublishingWeb.

De esta forma podemos obtener la navegación de los usuarios respetando cosas como pueden ser el orden que se ha establecido o si queremos mostrar subsites, páginas, etc.

Aquí añado un poco de código donde se muestran un uso de estas propiedades:

NOTA: Es necesario referencial la dll Microsoft.SharePoint.Publishing.dll

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Publishing;
using Microsoft.SharePoint.Navigation;
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
try
{
using (SPSite siteCollection = new SPSite("http://localhost"))
{
using (SPWeb site = siteCollection.OpenWeb())
{
PublishingWeb pw = PublishingWeb.GetPublishingWeb(site);
Console.WriteLine("Navegación actual de la site Nombre: {0}, Url: {1} ",site.Title,site.Url);
foreach (SPNavigationNode nodo in pw.CurrentNavigationNodes)
{
Console.WriteLine("Titulo: {0}, Url: {1}", nodo.Title, nodo.Url);
}
Console.WriteLine("Navegación global de la site Nombre: {0}, Url: {1} ", site.Title, site.Url);
foreach (SPNavigationNode nodo in pw.GlobalNavigationNodes)
{
Console.WriteLine("Titulo: {0}, Url: {1}", nodo.Title, nodo.Url);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
}

Acceder al QueryString con JavaScript

2009-01-28T06:17:00.001-08:00

Este post lo hago simplemente para recordarlo, que siempre se me olvida y me vuelvo loco buscando un ejemplo:

//Devuelve un array con la coleccion de parametros del queryString
function queryString() { 

    var qsParm = new Array(); 
    var query = window.location.search.substring(1); 
    var parms = query.split('&'); 

    for (var i=0; i<parms.length; i++) {
    
        var pos = parms[i].indexOf('='); 
        
        if (pos > 0) { 
        
            var key = parms[i].substring(0,pos); 
            var val = parms[i].substring(pos+1); 
            qsParm[key] = val; 
            
        } 
    } 
    
    return qsParm;
}

ConnectionString en SharePoint (MOSS 2007)

2009-01-28T04:13:00.000-08:00

La cadena de conexión para la base de datos de configuración es persistida en una clave de registro, consultando la clave específica podemos obtener la cadena de conexión.

1. Inicio --> Ejecutar: regedit
2. Navega por: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Shared Tools\Web Server Extensions\12.0\Secure\configdb

Trozo de código para obtenerla:

RegistryKey key = Registry.LocalMachine.CreateSubKey(@"SOFTWARE\Microsoft\Shared Tools\Web Server Extensions\12.0\Secure\configdb");

DSN = (string) key.GetValue("DSN");

SQLServerInstance = new string[]{this.DSN.Split(new char[] { '=', ';' })[1]};

key.Close();

Deshabilitar Mi Sitio y Mis vínculos en SharePoint (MOSS 2007)

2009-01-28T03:05:00.000-08:00

Para poder configurar quien puede ver Mi Sitio y Mis Vínculos en Microsoft Office SharePoint Server 2007 tendremos que seguir los siguientes pasos:

1. Ir a la Administración Central
2. In a la Administración de los Servicios Compartidos
3. Permisos de servicios de personalización
4. Agregarmos el grupo al que queremos dar permisos para crear sitios personales y marcamos los checkbox:
- Crear un sitio personal
- Utilizar características personales
5. Eliminamos el grupo NTAuthority\Authenticated Users que es el que viene por defecto.

De esta forma ya habremos limitado esta características a un grupo de directorio activo particular.

Si lo que queremos es simpelemente que ningún usuario vea estos links lo que podemos hacer es desactivar la feature que nos muestra estos links, en la master.page tenemos un sharepoint delegate control que se complementa con un user control a partir de una feature que está activada en el ámbito de toda la granja de servidores. Para deshabilitar esta feature:

C:\Program Files\Microsoft Shared\web server extensions\12\bin\>stsadm -o deactivatefeature -name MySite

Información extraida de:
http://geekswithblogs.net/RogueCoder/archive/2006/11/01/95766.aspx

Preparando Certificaciones en WSS 3.0 y MOSS 2007

2008-01-27T11:19:00.000-08:00

- MCTS: Windows SharePoint Services 3.0 - Configuration

Exam: 70-631
Course: 5060 - Implementing Microsoft Windows SharePoint Server 3.0

Module 1: Introduction to the Windows SharePoint Services 3.0 Platform
Module 2: Planning the Windows SharePoint Services 3.0 Environment
Module 3: Installing Windows SharePoint Services 3.0
Module 4: Upgrading from Windows SharePoint Services 2.0 to 3.0
Module 5: Managing Windows Windows SharePoint Services 3.0

Más información en: http://www.microsoft.com/learning/mcp/mcts/spservices/config/default.mspx

- MCTS: Microsoft Office SharePoint Server 2007 - Configuration

Exam: 70-630
Course: 5061 - Implementing Micorosft Office SharePoint Server 2007

Module 1: Overview of Microsoft Office SharePoint Server 2007
Module 2: Planning and Designing for Microsoft Office SharePoint Server 2007
Module 3: Deploying Microsoft Office SharePoint Server 2007
Module 4: Administering Microsoft Office SharePoint Server 2007
Module 5: Implementing Portal Solutions
Module 6: Implementing Content Management Solutions
Module 7: Implementing Business Intelligence Solutions
Module 8: Implementing Search and Indexing
Module 9: Maintaining and Optimizing Microsoft Office SharePoint Server 2007

Más información en: http://www.microsoft.com/learning/mcp/mcts/spserver/config/default.mspx

- MCTS: Windows SharePoint Services 3.0 - Application Development

Exam: 70-541
Book - Inside Microsoft Windows SharePoint Services Version 3.0

Chapter 1: Getting Started
Chapter 2: SharePoint Architecture
Chapter 3: Pages and Design
Chapter 4: Web Parts
Chapter 5: AJAX Web Parts
Chapter 6: Lists and Content Types
Chapter 7: Document Libraries
Chapter 8: SharePoint Workflows
Chapter 9: Solutions and Deployment
Chapter 10: Application Security

Más información en: http://www.microsoft.com/MSPress/books/9692.aspx

- MCTS: Microsoft Office SharePoint Server 2007 - Application Development

Exam: 70-542
Book - Inside Microsoft Office SharePoint Server 2007

Chapter 1: Introducing Microsoft Office SharePoint Server 2007
Chapter 2: Collaboration Portals and People Management
Chapter 3: Customizing and Extending the Microsoft Office SharePoint 2007 Search
Chapter 4: Working with the Business Data Catalog
Chapter 5: Infopath Forms Services
Chapter 6: Customizing and Branding Publishing Portals
Chapter 7: Integrating with Excel Services
Chapter 8: Policies and the Records Repository

Más información en: http://www.microsoft.com/MSPress/books/10472.aspx