lunes, 28 de junio de 2010

Habilitar Multi Tenant en Sharepoint 2010!!

Hola a tod@s!!

hoy os quiero explicar cómo habilitar el famoso e innovador multi tenant de Sharepoint 2010. Para empezar, un poco de teoría... ¿que es "Tenant"?
El concepto de Tenant se define por una zona operacional completamente aislada que el administrador global delega a otra persona para su administración.
Hablando más coloquial, es como tener varios Sharepoints totalmente diferentes e independientes.
En estos Tenants podremos administrar:

1.- Datos
2.- Desarrollos y features
3.- Uso
4.- Administración

Por supuesto, podremos compartir web applications entre nuestros Tenants.

Y ahora...¿cómo habilito la administración Multi Tenant?
Seguramente haya más de una manera de hacerlo, pero yo os voy a explicar la mía:



Consiste en una aplicación desarrollada en C# que crea un site del tipo TenantAdministration y luego la suscripción a ese site. Pero antes, deberemos de activar el self-service site creation en nuestra granja. Os pongo un pantallazo de la activación y el código de la aplicación:







static void Main(string[] args)
{
try
{
SPWebApplication spwWebApp = SPWebApplication.Lookup(new Uri("http://vmsp2010:15329"));
Console.WriteLine("HA HECHO EL LOOKUP");
SPSite spsSitio = spwWebApp.Sites.Add("/sites/tenantAdmin", "Tenant Administration 2", "Tenant Administration 2", Convert.ToUInt32(1033), "tenantadmin#0", "victor.cea", "victor.cea", "administrator@site.com");
Console.WriteLine( "Nueva Colección creada: {0}", spsSitio.RootWeb.Title);
spsSitio.AdministrationSiteType = SPAdministrationSiteType.TenantAdministration;
spsSitio.Dispose();
}
catch (Exception ex)
{
Console.WriteLine( "Error en la creación del Sitio: {0}",ex.Message);
}

try
{
SPSite spsSiteTenantAdmin = new SPSite("http://vmsp2010:15329/sites/tenantAdmin");
SPSiteSubscription spsSuscription = SPSiteSubscription.Create();
spsSuscription.Add(spsSiteTenantAdmin);
Console.WriteLine("Suscripción creada con éxito");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}

}

como veis, delego la administración al usuario victor.cea (en este caso yo) :)

Como resultado final del trabajo:



Suerte y a por los Tenants!!

miércoles, 9 de junio de 2010

Hoy va de Jobs...de SPJobs!!

Estos días en Raona he tenido la necesidad de tener que crear "algo" que se ejecute cada cierto tiempo para comprobar cierta información de una lista y enviar mails según si se cumplen unas condiciones en dicha lista.

Buscando y sobretodo ayudado por mis compañeros, descubrí los SPJobDefinition, como sabéis Job = trabajo. Un SPJobDefinition es un programa integrado en Sharepoint que se ejecuta cada cierto tiempo.

La manera por la cual aprendí a implementarlos y lo que es más importante, instalarlos, es la siguiente:

1.- Crear un SPJobDefinition (os pongo un ejemplo, y os explico):


namespace Test.TaskLogger {
public class TaskLoggerJob : SPJobDefinition{

public TaskLoggerJob ()
: base(){
}

public TaskLoggerJob (string jobName, SPService service, SPServer server, SPJobLockType targetType)
: base (jobName, service, server, targetType) {
}

public TaskLoggerJob (string jobName, SPWebApplication webApplication)
: base (jobName, webApplication, null, SPJobLockType.ContentDatabase) {
this.Title = "Task Logger";
}

public override void Execute (Guid contentDbId) {
// get a reference to the current site collection's content database
SPWebApplication webApplication = this.Parent as SPWebApplication;
SPContentDatabase contentDb = webApplication.ContentDatabases[contentDbId];

// get a reference to the "Tasks" list in the RootWeb of the first site collection in the content database
SPList taskList = contentDb.Sites[0].RootWeb.Lists["Tasks"];

// create a new task, set the Title to the current day/time, and update the item
SPListItem newTask = taskList.Items.Add();
newTask["Title"] = DateTime.Now.ToString();
newTask.Update();
}
}
}


Un SPJobDefinition tiene varias funciones importantes definidas pero la que nos importa es la función Execute. Dentro de la función Execute escribiremos el código que queremos que se ejecute (valga la redundancia) cada vez que el job se lance.


2.- Crear una Feature que se encargue de activar ese job (os pongo aquí un ejemplo y os explico):


namespace Test.TaskLogger {
class TaskLoggerJobInstaller : SPFeatureReceiver {
const string TASK_LOGGER_JOB_NAME = "TaskLogger";
public override void FeatureInstalled (SPFeatureReceiverProperties properties) {
}

public override void FeatureUninstalling (SPFeatureReceiverProperties properties) {
}

public override void FeatureActivated (SPFeatureReceiverProperties properties) {
SPSite site = properties.Feature.Parent as SPSite;

// make sure the job isn't already registered
foreach (SPJobDefinition job in site.WebApplication.JobDefinitions) {
if (job.Name == TASK_LOGGER_JOB_NAME)
job.Delete();
}

// install the job
TaskLoggerJob taskLoggerJob = new TaskLoggerJob(TASK_LOGGER_JOB_NAME, site.WebApplication);

SPMinuteSchedule schedule = new SPMinuteSchedule();
schedule.BeginSecond = 0;
schedule.EndSecond = 59;
schedule.Interval = 5;
taskLoggerJob.Schedule = schedule;

taskLoggerJob.Update();
}

public override void FeatureDeactivating (SPFeatureReceiverProperties properties) {
SPSite site = properties.Feature.Parent as SPSite;

// delete the job
foreach (SPJobDefinition job in site.WebApplication.JobDefinitions) {
if (job.Name == TASK_LOGGER_JOB_NAME)
job.Delete();
}
}
}
}

En nuestro caso, la función que nos interesa de la feature que activa el Job es la FeatureActivated. Si nos fijamos lo primero que hace es buscar que no tengamos ya un Job definido con el mismo nombre, para no duplicar y que hubieran problemas.

3.- Lo siguiente es crear un nuevo job con las variables que necesita el constructor de ese Job.

4.- Luego tenemos que definir con que frecuencia ese job será ejecutado en el sistema. En este ejemplo se ejecuta cada minuto, por eso la definición de:

SPMinuteSchedule schedule = new SPMinuteSchedule();

las otras opciones son:

SPDailySchedule (cada día)
SPMonthlySchedule (cada mes)
SPHourlySchedule (cada hora)

(Buscar información sobre estas características ya que cada una tiene su propia definición de horario de ejecución, por ejemplo, SPDailySchedule tienes que definir una hora de empiece y otra de fin para que se ejecute durante el día).

5.- Por último para activar la feature coger un xml de cualquier otra feature (disponibles en el directorio 12 de Sharepoint, directorio TEMPLATE/FEATURES, (cada carpeta es una feature)) y adecuar el xml de cualquiera a nuestra feature.
Y ahora si, por últimisimo tenemos que instalar y activar la feature, a la vez que la feature nos activará el job (podréis ver que lo tenéis ya instalado en la "Central Administration" de SP en los Jobs Definitions.

5.b.- Para instalar la feature:

http://technet.microsoft.com/en-us/library/cc263123(office.12).aspx

Para activar la feature:

http://technet.microsoft.com/es-es/library/cc262692(office.12).aspx

Suerte y a por ello!!!

viernes, 4 de junio de 2010

Event Handlers!!

Hola!!

como ayer dije, hoy hablaré de los events en Sharepoint. Hace relativamente poco que estoy trabajando con ellos, y creo que son muy interesantes y potentes.
Un event handler no es más que un tipo de trigger, un evento que se activa cuando algo ocurre, la traducción literal es control de eventos.
Un control handler se puede asociar a diferentes niveles:

  • A nivel de site: SPWebEventReceiver

  • A nivel de list: SPListEventReceiver

  • A nivel de listitem: SPListItemEventReceiver


Cada uno de los niveles posee una serie de métodos particulares y definidos según la clasificación anterior que hay en el siguiente blog msdn y que os ayudará muchísimo:

http://blogs.msdn.com/b/brianwilson/archive/2007/03/05/part-1-event-handlers-everything-you-need-to-know-about-microsoft-office-sharepoint-portal-server-moss-event-handlers.aspx

Como podréis observar hay diferentes métodos, para existe una diferencia significativa entre ellos, los acabados en -ed y los acabados en -ing.

Como os imagenaréis, la diferencia es que los acabados en -ed se ejecutan despues de la acción, en cambio los acabados en -ing se ejecutan antes de la acción.


Hay que tener en cuenta que los eventos before (acabados en -ing) bloquean el código de ejecución hasta que el evento no acaba, con lo que si no estan bien implementados nos pueden proveer de malas sorpresas.

Una vez explicados los event handlers, voy a explicaros mi método de asociación a listas, items o sites de Sharepoint.

Imaginaos (o probad mejor dicho :P) que ya tenéis un event implementado y lo habéis ya deployado en vuestra site collection. Pues bien, gracias a mis compañeros descubrí el siguiente programa:


MOSSEventManager:



Como veis es un programa donde te "capta" los site collections de tu Sharepoint, representado toda la estructura por sites, listas, etc... y en la parte derecha salen todos los eventos registrados. Observad el último (event1) es una prueba que yo implementé.
El siguiente paso es hacer click en la lista, site, etc... deseado, y hacer click en el evento que quieras asociar, luego hacemos click en Update List Events...y ya tenemos el evento asociado!

Así de sencillo. En Codeplex existe un sistema de administración de eventos, pero creo que es más sencillo el que yo utilizo, para gustos, colores!!

jueves, 3 de junio de 2010

Mi primer SPListItem :)

Hola a tod@s,

hoy día 3 de Junio, queda inaugurado mi nuevo blog sobre la tecnología Sharepoint. Como presentación os puedo adelantar que me llamo Víctor, tengo 23 años (cumplidos hoy), soy ingeniero técnico en informática de sistemas, y pertenezco a la consultoría Raona.
Me apasiona todo lo relacionado con las nuevas tecnologías, y sobretodo lo relacionado con Sharepoint.
Este blog tiene como finalidad poder compartir mis dudas resueltas (o no), poder aportar mis conocimientos sobre Sharepoint a quién quiera adquirirlos y como no, poder resolver dudas a quién las tenga.

Espero que lo sigáis de cerca y opinéis, que donde hay opinión hay conocimiento, y eso es muy bueno.

Mañana mi primer post sobre Event Handlers en Sharepoint, hace poco que he empezado a trabajar con ellos y los encuentros muy interesantes.