• Télécharger le projet - 6Ko

Cet article a pour but de montrer comment créer facilement une WebPart en utilisant des composants existants. On utilise dans cet exemple un composant d'édition HTML gratuit : FreeTextBox

Une WebPart est un control Web fournit avec WSS qui propose des comportements par défaut afin de s'intégrer efficacement dans un environnement WSS.

Elle possède en standard :

• la possibilité d'être déplacée d'une zone à une autre
• une zone de modification de propriété
• l'intégration du « Look and Feel »

Exemple (WebPart d'édition de news) :

Microsoft met à disposition un template pour Visual Studio .Net 2003 qui permet de créer facilement des WebParts.

Web Part Templates for Visual Studio .NET

Lors de l'installation, une fenêtre de dialogue demande le chemin pour accéder à l'assembly de Windows Sharepoint Services. Elle se trouve dans le répertoire local_drive\Program Files\Common Files\Microsoft Shared\Web Server Extensions\60\ISAPI\ du serveur sur lequel est installé Windows Sharepoint Services.

La création de la WebPart se base sur le template Visual Studio précédemment installé.

Créer un nouveau projet de type « WebPartLibrary » :



Le template par défaut créé une classe WebPart (WebPart1) :

using System;
using System.ComponentModel;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Xml.Serialization;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Utilities;
using Microsoft.SharePoint.WebPartPages;

namespace DemoWebPartLibrary
{
	/// <summary>
	/// Description for WebPart1.
	/// </summary>
	[DefaultProperty("Text"),
		ToolboxData("<{0}:WebPart1 runat=server></{0}:WebPart1>"),
		XmlRoot(Namespace="DemoWebPartLibrary")]
	public class WebPart1 : Microsoft.SharePoint.WebPartPages.WebPart
	{
		private const string defaultText = "";

		private string text = defaultText;

		[Browsable(true),
			Category("Miscellaneous"),
			DefaultValue(defaultText),
			WebPartStorage(Storage.Personal),
			FriendlyName("Text"),
			Description("Text Property")]
		public string Text
		{
			get
			{
				return text;
			}

			set
			{
				text = value;
			}
		}
		
		/// <summary>
		/// Render this Web Part to the output parameter specified.
		/// </summary>
		/// <param name="output"> The HTML writer to write out to </param>
		protected override void RenderWebPart(HtmlTextWriter output)
		{
			output.Write(SPEncode.HtmlEncode(Text));
		}
	}
}

Description :

Une WebPart doit être en mesure de pouvoir :

• s'afficher correctement (rendu HTML)
• sauvegarder son état (de préférence dans la base de données dédiée à Windows Sharepoint Services)

L'affichage des données se fait à l'aide de deux méthodes connues de toute personne ayant déjà développé des UserControls :

• RenderWebPart (idem à Render pour un UserControl)
• CreateChildControls

protected override void RenderWebPart(HtmlTextWriter output)
{
	output.Write(SPEncode.HtmlEncode(Text));
}

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

	TextBox tb = new TextBox();
	tb.Text = "coucou";
}

La première méthode permet d'écrire dans un flux HTML qui sera renvoyé par le serveur pour représenter la WebPart. Dans l'exemple ci-dessus, la représentation du WebPart est le contenu de la propriété Text de notre classe. On utilise cette méthode dans les cas où l'on veut afficher des données sans effectuer de traitements dessus.
La deuxième méthode permet de travailler au niveau des objets et d'ajouter des contrôles Web à la collection détenue par la WebPart. Cette méthode est préconisée dans le cas où l'on veut gérer des évènements. C'est le cas pour notre WebPart d'édition HTML. Dans l'exemple ci-dessus, la représentation de la WebPart est un TextBox contenant la chaîne de caractères « coucou ».

Une WebPart doit être en mesure de sauvegarder son état. Elle peut le faire de 2 façons :

• implémenter sa proche logique de persistance (XML, Base de données, ...)
• utiliser la logique mise à disposition par les WebParts

On se basera sur la deuxième solution plus adaptée à notre exemple et préconisée par Microsoft. La persistance des WebParts se définit à l'aide d'attributs listés ci-dessous :

• Browsable : Définit si cette propriété peut être modifiée par la zone de modification des propriétés de WSS
  
  
• Category : Définit la catégorie dans laquelle peut être modifié cette propriété
• DefaultValue : Valeur par défaut affectée à cette propriété
• WebPartStorage : Permet de définir où et comment est sauvegardé le contenu de la propriété (valeurs possibles de type énumération : Storage.Personal – Storage.Shared)

Le travail à réaliser est très simple. Il faut :

• intégrer le contrôle Web (FreeTextBox) dans notre WebPart par l'intermédiaire de la méthode « CreateChildControls »
• sauvegarder son contenu en base de données à l'aide des attributs
• créer un LinkButton qui permet de prendre en compte les modifications

using System;
using System.ComponentModel;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Xml.Serialization;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Utilities;
using Microsoft.SharePoint.WebPartPages;


namespace DemoWebPartLibrary
{
	/// <summary>
	/// Description for WebPart1.
	/// </summary>
	[DefaultProperty("HtmlContent"),
	ToolboxData("<{0}:WebPart1 runat=server></{0}:WebPart1>"),
	XmlRoot(Namespace="DemoWebPartLibrary")]
	public class WebPart1 : Microsoft.SharePoint.WebPartPages.WebPart
	{

		private string _htmlContent = "";

		// Controles
		private FreeTextBoxControls.FreeTextBox tBox;

		[Browsable(false),
		Category("Miscellaneous"),
		DefaultValue(""),
		WebPartStorage(Storage.Shared),
		FriendlyName("HTML Content"),
		Description("HTML Content")]
		public string HtmlContent
		{
			get
			{
				return _htmlContent;
			}

			set
			{
				_htmlContent = value;
			}
		}
		
		protected override void CreateChildControls()
		{
			base.CreateChildControls ();

			// Test si on est en mode dition
			if (BrowserDesignMode) 
			{
				// Cration du controle
				tBox = new FreeTextBoxControls.FreeTextBox();
				tBox.ID = "FreeTextBox";
				tBox.ButtonFileExtention = "gif";
				tBox.ButtonPath = "http://frkusps0/_layouts/images/ftb/office2003/";
			
				// Initialisation du controle
				tBox.Text = HtmlContent;

				// Ajout du controle
				Controls.Add(tBox);

				// Cration du controle
				LinkButton lBSave = new LinkButton();
				
				// Initialisation
				lBSave.Text = "Sauvegarder";
				// Gestion des vnements
				lBSave.Click += new EventHandler(OnSave);
				
				// Ajout du controle
				Controls.Add(new LiteralControl("<br>"));
				Controls.Add(lBSave);
			}
			else 
			{
				Controls.Add(new LiteralControl(HtmlContent));
			}

		}

		private void OnSave(object sender, EventArgs args) 
		{
			// Lors de la demande de sauvegarde
			HtmlContent = tBox.Text;
			this.SaveProperties = true;
		}

	}
}

Remarques : La propriété SaveProperties est mise à true pour signaler qu'il faut enregistrer en base de données les modifications de la propriété.

Pour pouvoir déployer notre assembly, il faut :

• signer notre Assembly
• copier l'Assenblie dans le GAC du serveur
• la déclarer comme sûre dans le fichier de configuration du serveur (Web.Config)
• créer le fichier de description de notre WebPart (.dwp) pour l'importation

Signer l'Assembly

Voir les nombreux articles qui en parle (commande sn –k fournie avec le SDK)

Modifier le fichier de configuration (Web.Config)

<SafeControls>
	<SafeControl Assembly="DemoWebPartLibrary, Version=1.0.0.0, Culture=neutral, PublicKeyToken=fb1f6448d3cb82ee" Namespace="DemoWebPartLibrary" TypeName="*" Safe="True" />
</SafeControls>

Sharepoint exploite pleinement la sécurité au niveau des Assemblys et demande pour intégrer une WebPart que celle-ci soit déclarée comme sûre dans le fichier de configuration.

Fichier de description (.dwp)

Ce fichier est la description XML de la WebPart qui permet ensuite de l'importer dans une page WSS.

<?xml version="1.0" encoding="utf-8"?>
<WebPart xmlns="http://schemas.microsoft.com/WebPart/v2" >
	<Title>WebPartFreeTextBox</Title>
	<Description>WebPartFreeTextBox.</Description>
	<Assembly>DemoWebPartLibrary, Version=1.0.0.0, Culture=neutral, PublicKeyToken=fb1f6448d3cb82ee</Assembly>
	<TypeName>DemoWebPartLibrary.WebPart1</TypeName>
	<!-- Specify initial values for any additional base class or custom properties here. -->
</WebPart>

Les données les plus importantes sont :

• Le nom de l'Assembly : Toutes les informations relative à l'Assembly peuvent être trouvées grâce à l'explorateur d'Assembly
  
  
  
  
• Le typeName : Chemin complet à travers le NameSpace pour atteindre notre WebPart (Classe)

Remarques : Pour que toutes ces modifications soient prises en compte, il faut redémarrer IIS (commande dos iisreset)

La phase de test comporte plusieurs étapes :

• importation de la WebPart à l'aide du fichier de description (.dwp)
• tester le fonctionnement de la WebPart

Importation du WebPart :





Glisser déposer sur la zone de travail :



Passer en mode édition :





Test de la sauvegarde et de l'affichage HTML :

La création d'une WebPart est assez facile et permet d'ajouter rapidement des fonctionnalités à WSS. On verra dans un prochain article comment on peut facilement personnaliser le panneau de propriété de WSS.