Création d'un portail web ASP.NET pour générer des rapports avec Crystal Reports

Date de publication : 18/08/2005

Par David Pédehourcq (Mon blog)
 

Dans cet article, nous allons voir comment créer un portail ASP.NET qui génèrera des rapports au format Word, PDF ou Excel à l'aide de Crystal Reports. Ce portail web sera modulable et entièrement configurable via un fichier xml afin de pouvoir rajouter ou enlever des états sans avoir à recompiler l'application.

Avant-propos

Cet article va essayer de répondre à deux problèmatiques :
• Créer un système de reporting web supportant divers formats (Word, PDF, Excel).
  
• Créer un système de reporting web assez flexible pour permettre l'ajout, la suppression et la modification d'états sans recompiler l'application

I. Mécanismes de génération d'un état

Nous allons commencer par analyser rapidement les différentes étapes de génération d'un état. Un schéma simple valant de long discours :

Pour générer un état, il nous faut donc :
• Des critères d'extraction de données.
  
• Une méthode qui va extraire les données.
  
• Un modèle d'état : un chemin vers un modèle d'état Crystal Reports (.rpt).

II. Description d'un état dans un fichier xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<descetats>
 <etat>
  <libcourt>Etat1</libcourt>
  <liblong>Lib Long Etat1</liblong>
  <pathreport>EtatsCR\report1.rpt</pathreport>
  <methodgetdata>GetDataReport</methodgetdata>
  <control>
   <Libcontrol>param1</Libcontrol>
   <pathcontrol>Controles/control1.ascx</pathcontrol>
  </control>
  <control>
   <Libcontrol>param2</Libcontrol>
   <pathcontrol>Controles/control1.ascx</pathcontrol>
  </control>
  <control>
   <Libcontrol>param3</Libcontrol>
   <pathcontrol>Controles/control3.ascx</pathcontrol>
  </control>
 </etat>
</descetats>

Explication des balises :
• <etat></etat> : la description d'un etat.
  
• <libcourt></libcourt> : c'est le nom qu'aura l'état dans le menu de la page web.
  
• <liblong></liblong> : c'est le titre qu'aura la page web de l'état.
  
• <pathreport></pathreport> : c'est le chemin du modèle Crystal Reports de l'état.
  
• <methodgetdata></methodgetdata> : c'est le nom de la méthode qui se chargera d'extraire les données.
  
• <control></control> : un contrôle utilisateur de saisie.
  
• <libcontrol></libcontrol> : le libellé se trouvant devant le contrôle de saisie.
  
• <pathcontrol></pathcontrol> : le chemin du contrôle utilisateur de saisie.
  

<?xml version="1.0" ?>
<xs:schema id="descetats" targetNamespace="http://tempuri.org/descetats.xsd" 
 xmlns:mstns="http://tempuri.org/descetats.xsd"
 xmlns="http://tempuri.org/descetats.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema" 
 xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"
 attributeFormDefault="qualified" elementFormDefault="qualified">
 <xs:element name="descetats" msdata:IsDataSet="true" msdata:Locale="fr-FR" msdata:EnforceConstraints="False">
  <xs:complexType>
   <xs:choice maxOccurs="unbounded">
    <xs:element name="etat">
     <xs:complexType>
      <xs:sequence>
       <xs:element name="libcourt" type="xs:string" minOccurs="0" />
       <xs:element name="liblong" type="xs:string" minOccurs="0" />
       <xs:element name="pathreport" type="xs:string" minOccurs="0" />
       <xs:element name="control" minOccurs="0" maxOccurs="unbounded">
        <xs:complexType>
         <xs:sequence>
          <xs:element name="Libcontrol" type="xs:string" minOccurs="0" />
          <xs:element name="mapproperty" type="xs:string" minOccurs="0" />
          <xs:element name="pathcontrol" type="xs:string" minOccurs="0" />
         </xs:sequence>
        </xs:complexType>
       </xs:element>
      </xs:sequence>
     </xs:complexType>
    </xs:element>
   </xs:choice>
  </xs:complexType>
 </xs:element>
</xs:schema>

<?xml version="1.0" encoding="ISO-8859-1"?>
<descetats xmlns="http://tempuri.org/descetats.xsd">

J'ai choisi d'utiliser un dataset fortement typé sur le xml de description des états pour faciliter l'écriture du code permettant de récupérer les informations du fichier. Ce choix est certainement discutable mais rien ne vous empêche de procéder différemment. L'impact sur les performances est, à mon avis, négligeable car les informations du XML seront mises en cache et non récupérées à chaque requête du portail web.

III. Récupération des informations XML des états

DescEtatsFactory.cs
using System;
using System.Xml;
namespace EtatsMetier
{
 /// <summary>
 /// Description résumée de descEtatsFactory.
 /// </summary>
 public class DescEtatsFactory
 {
  private static descetats m_dataDescEtats;
  public static descetats GetEtatDesc()
  {
   //s'il n'y a pas d'instance du dataset m_dataDescEtats, on en crée une
   if(m_dataDescEtats == null)
   {
    m_dataDescEtats = CreateListEtatsDesc();
   }
   return(m_dataDescEtats);
  }
  //on crée une instance de dataDescEtats qu'on remplit
  private static descetats CreateListEtatsDesc()
  {
   descetats dataDescEtats;
   dataDescEtats = new descetats();
   XmlDataDocument m_doc = new XmlDataDocument(dataDescEtats);
   m_doc.Load(System.AppDomain.CurrentDomain.BaseDirectory + "EtatsMetier/descetats.xml");
   return(dataDescEtats);
  }
  //On détruit l'instance courante de descetats
  public static void KillInstance()
  {
   m_dataDescEtats = null;
  }
 }
}

Pour faire simple, j'ai considéré ici que la couche "EtatsMetier" sera toujours à la racine de mon application web. Pour plus de flexibilité, on peut placer le chemin du fichier "descetats.xml" dans un fichier .config.

Global.asax.cs
public class Global : System.Web.HttpApplication
 {
       
  /// <summary>
  /// Variable nécessaire au concepteur.
  /// </summary>
  private System.ComponentModel.IContainer components = null;
        public System.IO.FileSystemWatcher m_watcher;
  public Global()
  {
   InitializeComponent();
   m_watcher = new System.IO.FileSystemWatcher(System.AppDomain.CurrentDomain.BaseDirectory + "EtatsMetier/");
   m_watcher.NotifyFilter = System.IO.NotifyFilters.LastWrite;
   m_watcher.Filter="descetats.xml";
   m_watcher.Changed+=new System.IO.FileSystemEventHandler(m_watcher_Changed);
   m_watcher.EnableRaisingEvents = true;
  }
  private void m_watcher_Changed(object sender, System.IO.FileSystemEventArgs e)
  {
  EtatsMetier.DescEtatsFactory.KillInstance();
  } 
 }

IV. Création des contrôles utilisateurs web

IControlEtat.cs
using System;
namespace Etats
{
 //Interface que doit implémenter tout contrôle utilisateur de Etats
 public interface IControlEtat
 {
  //Méthode qui va retourner la valeur saisie sur le contrôle
  object GetData();
  //Propriété gérant le libellé du contrôle
  string Libelle{get;set;}
 }
}

Compte tenu de la simplicité de l'interface, vous vous dites sûrement qu'on aurait pu s'en passer. Mais les contrôles utilisateurs de cette application seront peut-être emmenés à se complexifier. Autant prévoir dès le début, une interface commune à tous ces contrôles.

A. Un contrôle utilisateur web simple

CtrlDate.ascx
<%@ Register="ew" Namespace="eWorld.UI" Assembly="eWorld.UI" %>
<%@ Control="c#" AutoEventWireup="false" Codebehind="CtrlDate.ascx.cs" 
Inherits="Etats.Controles.CtrlDate" TargetSchema="http://schemas.microsoft.com/intellisense/ie5"%>
<asp:Label id="lblLibelle" runat="server"></asp:Label>
<ew:CalendarPopup id="DTP" runat="server" Width="88px"></ew:CalendarPopup>
<br><br>

J'utilise ici un contrôle date time piquer qui n'est pas présent dans le framework .NET mais que vous pouvez retrouver ici :  contrôle Date Time picker. Je vous recommande de le tester, il remplace avantageusement le calendaire d'ASP.NET.

CtrlDate.ascx.cs
namespace Etats.Controles
{
 using System;
 using System.Data;
 using System.Drawing;
 using System.Web;
 using System.Web.UI.WebControls;
 using System.Web.UI.HtmlControls;

 /// <summary>
 /// Description résumée de CtrlDate.
 /// </summary>
 public class CtrlDate : System.Web.UI.UserControl, IControlEtat
 {
  protected eWorld.UI.CalendarPopup DTP;
  protected System.Web.UI.WebControls.Label lblLibelle;

  private void Page_Load(object sender, System.EventArgs e)
  {
   // Placer ici le code utilisateur pour initialiser la page
  }

  #region Code généré par le Concepteur Web Form
  override protected void OnInit(EventArgs e)
  {
   //
   // CODEGEN : Cet appel est requis par le Concepteur Web Form ASP.NET.
   //
   InitializeComponent();
   base.OnInit(e);
  }
  
  /// <summary>
  ///  Méthode requise pour la prise en charge du concepteur - ne modifiez pas
  ///  le contenu de cette méthode avec l'éditeur de code.
  /// </summary>
  private void InitializeComponent()
  {
   this.Load += new System.EventHandler(this.Page_Load);

  }
  #endregion
 
  #region Membres de IControlEtat

  public object GetData()
  {
   return (this.DTP.SelectedDate);
  }

  public string Libelle
  {
   get
   {
    return this.lblLibelle.Text;
   }
   set
   {
    this.lblLibelle.Text = value;
   }
  }
  #endregion
 }
}

B. Un contrôle utilisateur web plus complexe : saisie d'une période

Structs.cs
using System;
namespace MetierEtats
{
 public struct Periode
 {
  public DateTime DateD;
  public DateTime DateF;
 }
}

CtrlPeriode.ascx
<%@ Register TagPrefix="ew" Namespace="eWorld.UI" Assembly="eWorld.UI" %>
<%@ Control Language="c#" AutoEventWireup="false" 
Codebehind="CtrlPeriode.ascx.cs" Inherits="Etats.Controles.CtrlPeriode" 
TargetSchema="http://schemas.microsoft.com/intellisense/ie5"%>
<asp:Label id="lblLibelle" runat="server"></asp:Label>&nbsp;du&nbsp;
<ew:CalendarPopup id="DTPDebut" runat="server"></ew:CalendarPopup>&nbsp;au&nbsp;
<ew:CalendarPopup id="DTPFin" runat="server"></ew:CalendarPopup>
<br><br>

CtrlPeriode.ascx.cs
namespace Etats.Controles
{
 using System;
 using System.Data;
 using System.Drawing;
 using System.Web;
 using System.Web.UI.WebControls;
 using System.Web.UI.HtmlControls;
 using EtatsMetier;
 /// <summary>
 /// Description résumée de CtrlPeriode.
 /// </summary>
 public class CtrlPeriode : System.Web.UI.UserControl, IControlEtat
 {
  protected eWorld.UI.CalendarPopup DTPDebut;
  protected System.Web.UI.WebControls.Label lblLibelle;
  protected eWorld.UI.CalendarPopup DTPFin;

  private void Page_Load(object sender, System.EventArgs e)
  {
   // Placer ici le code utilisateur pour initialiser la page
  }

  #region Code généré par le Concepteur Web Form
  override protected void OnInit(EventArgs e)
  {
   //
   // CODEGEN : Cet appel est requis par le Concepteur Web Form ASP.NET.
   //
   InitializeComponent();
   base.OnInit(e);
  }
  
  /// <summary>
  ///  Méthode requise pour la prise en charge du concepteur - ne modifiez pas
  ///  le contenu de cette méthode avec l'éditeur de code.
  /// </summary>
  private void InitializeComponent()
  {
   this.Load += new System.EventHandler(this.Page_Load);

  }
  #endregion
 
  #region Membres de IControlEtat
  public object GetData()
  {
   Periode p;
   p.DateD = this.DTPDebut.SelectedDate;
   p.DateF=this.DTPFin.SelectedDate;
   return (p);
  }
  public string Libelle
  {
   get
   {
    return this.lblLibelle.Text;
   }
   set
   {
    this.lblLibelle.Text = value;
   }
  }
  #endregion
 }
}

C. Un contrôle utilisateur web avec accès aux données

• Du nom de la table où l'on va chercher les enregistrements.
  
• Du libellé d'un enregistrement.
  
• De la clé de l'enregistrement.
  

FillDDL.cs
using System;
using System.Data;
using System.Data.OleDb;
using System.Collections;
namespace EtatsMetier
{
 /// <summary>
 /// Description résumée de FillDDL.
 /// </summary>
 //structure d'un champ d'une liste déroulante
 public struct champDDL
 {
  public string ID;
  public string Libelle;
 }
 public class FillDDL
 {
  public static ArrayList GetData(string ChampCle, string ChampLib, string TableName)
  {
   champDDL m_champ;
   ArrayList m_result = new ArrayList();
   OleDbDataReader m_reader;
   OleDbConnection m_conn;
   using (m_conn= new OleDbConnection(@"Jet OLEDB:Database Password=;Data Source=" + 
   System.AppDomain.CurrentDomain.BaseDirectory + 
   @"\Comptoir.mdb";Password=;Provider="Microsoft.Jet.OLEDB.4.0";"))
   {
    OleDbCommand m_comm = m_conn.CreateCommand();
    //on crée la requete
    m_comm.CommandText="SELECT "+ ChampCle +"," + ChampLib +"FROM"+ TableName;
    m_conn.Open();
    m_reader= m_comm.ExecuteReader();
    //on remplis m_result de m_champ
    while(m_reader.Read())
    {
     m_champ.ID = m_reader.GetValue(0).ToString();
     m_champ.Libelle = m_reader.GetValue(1).ToString();
     m_result.Add(m_champ);
    }
    m_reader.Close();
    m_conn.Close();
   }
   //on retourne un arrayList prête à remplir une liste déroulante
   return(m_result);
  }
 }
}

Pour éviter de trop surcharger l'article, je ferais abstraction de toutes les problématiques liées à l'accès aux données. Il est évident qu'il ne faut jamais mettre une chaîne de connection en dur dans le code. Des liens vers des articles connexes permettant de mieux appréhender ces problématiques seront fournis en fin d'article.

CtrlDDLEmploye.ascx
<%@ Control="c#" AutoEventWireup="false" 
Codebehind="CtrlDDLEmploye.ascx.cs" Inherits="Etats.Controles.CtrlDDLEmploye" 
TargetSchema="http://schemas.microsoft.com/intellisense/ie5"%>
<asp:Label id="lblLibelle" runat="server"></asp:Label>
<asp:DropDownList id="DDLEmploye" runat="server"></asp:DropDownList>
<br><br>

CtrlDDLEmploye.ascx.cs
namespace Etats.Controles
{
 using System;
 using System.Drawing;
 using System.Web;
 using System.Web.UI.WebControls;
 using System.Web.UI.HtmlControls;
 using EtatsMetier;

 /// <summary>
 /// Description résumée de CtrlDDLEmploye.
 /// </summary>
 public class CtrlDDLEmploye : System.Web.UI.UserControl,IControlEtat
 {
  protected System.Web.UI.WebControls.Label lblLibelle;
  protected System.Web.UI.WebControls.DropDownList DDLEmploye;

  private void Page_Load(object sender, System.EventArgs e)
  {
   //On charge la liste déroulante
   foreach(champDDL m_champ in FillDDL.GetData("[N° employé]","[Nom]","[Employés]"))
   {
    this.DDLEmploye.Items.Add(new ListItem(m_champ.Libelle,m_champ.ID));
   }
  }

  #region Code généré par le Concepteur Web Form
  override protected void OnInit(EventArgs e)
  {
   //
   // CODEGEN : Cet appel est requis par le Concepteur Web Form ASP.NET.
   //
   InitializeComponent();
   base.OnInit(e);
  }
  
  /// <summary>
  ///  Méthode requise pour la prise en charge du concepteur - ne modifiez pas
  ///  le contenu de cette méthode avec l'éditeur de code.
  /// </summary>
  private void InitializeComponent()
  {
   this.Load += new System.EventHandler(this.Page_Load);

  }
  #endregion
 
  #region Membres de IControlEtat

  public object GetData()
  {
   return(System.Convert.ToInt32(this.DDLEmploye.SelectedValue));
  }
  public string Libelle
  {
   get
   {
    return this.lblLibelle.Text;
   }
   set
   {
    this.lblLibelle.Text = value;
   }
  }
  #endregion
 }
}

Ici, Microsoft nous montre bien ce qu'il ne faut surtout pas faire pour le nommage des champs d'une table le champ "N° employé" est une abomination (et je pèse mes mots) les "[" et "]" sont des caractères spécifiques à ACCESS qui permettent de spécifier les bornes d'un champ et de ne pas faire échouer le moteur SQL; sur le champ "N° employé", on peut relever 3 erreurs sur ce champ : Un caractère spécial "°" Un espace dans le nom du champ Un caractère accentué Je vous conseille de lire :  les règles de nomage du SQL

V. Chargement des contrôles utilisateur web

descetats.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<descetats xmlns="http://tempuri.org/descetats.xsd">
 <etat>
  <libcourt>Etat1</libcourt>
  <liblong>Lib Long Etat1</liblong>
  <pathreport>EtatsCR\report1.rpt</pathreport>
  <methodgetdata>GetDataReport</methodgetdata>
  <control>
   <Libcontrol>une date :</Libcontrol>
   <pathcontrol>Controles/CtrlDate.ascx</pathcontrol>
  </control>
  <control>
   <Libcontrol>une période :</Libcontrol>
   <pathcontrol>Controles/CtrlPeriode.ascx</pathcontrol>
  </control>
  <control>
   <Libcontrol>un employés :</Libcontrol>
   <pathcontrol>Controles/CtrlDDLEmploye.ascx</pathcontrol>
  </control>
 </etat>
</descetats>

Default.aspx
<%@ Page="c#" Codebehind="Default.aspx.cs" AutoEventWireup="false" Inherits="Etats.Default" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
 <HEAD>
  <title>WebForm1</title>
   <meta name="GENERATOR" Content="Microsoft Visual Studio .NET 7.1">
    <meta name="CODE_LANGUAGE" Content="C#">
 <meta name="vs_defaultClientScript" content="JavaScript">
 <meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5">
 </HEAD>
 <body>
  <form id="Form1" method="post" runat="server">
   <div align="center"><asp:Label ID="TitrePage" Runat="server">Bienvenue
   </asp:Label></div>
   <br><br><br><br>
   <table>
 <tr>
  <td valign="top">
   <table id="menu" runat="server" cellspacing="5" cellpadding="5" border="1">
      </table>
     </td>
     <td>
   <asp:placeholder id="placeControls" Runat="server"></asp:placeholder>
  </td>
    </tr>
   </table>
  </form>
 </body>
</HTML>

ControlFactory.cs
using System;
using System.Web;
using System.Web.UI;
using EtatsMetier;
namespace Etats
{
 /// <summary>
 /// Description résumée de ControlFactory.
 /// </summary>
 public class ControlFactory
 {
  //Initialise un contrôle à partir de sa description.
  public static Control LoadControlEtat(descetats.controlRow ControlEtats, Page page)
  {
   //On passe par l'interface IControl afin d'initialiser les propriétés 
   //spécifiques au contrôle utilisateur web des états
   IControlEtat m_control;
   m_control = (IControlEtat)page.LoadControl(ControlEtats.pathcontrol);
   m_control.Libelle = ControlEtats.Libcontrol;
   //On retourne le control initialisé en le castant en "Control" 
   //pour qu'on puisse directement l'insérer dans le place Holder.
   return((Control)m_control);
  }
 }
}

Default.aspx.cs
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using EtatsMetier;

namespace Etats
{
 /// <summary>
 /// Description résumée de WebForm1.
 /// </summary>
 public class Default : System.Web.UI.Page
 {
  protected System.Web.UI.WebControls.PlaceHolder placeControls;
  protected System.Web.UI.WebControls.Label TitrePage;
  //Element de HTMLTable pour générer le menu
  protected System.Web.UI.HtmlControls.HtmlTable menu;
  protected System.Web.UI.HtmlControls.HtmlTableRow TRmenu;
  protected System.Web.UI.HtmlControls.HtmlTableCell TDmenu;
  protected System.Web.UI.WebControls.Button btnGenerer;
  protected System.Web.UI.WebControls.DropDownList ddlFormat;
  protected System.Web.UI.WebControls.Panel PanelOptions;
  //Description des états
  protected descetats m_descEtats;
  private void Page_Load(object sender, System.EventArgs e)
  {
   //On récupère la description des états
   m_descEtats = DescEtatsFactory.GetEtatDesc();

   ///////////////////////////
   ///Génération du menu/////
   //////////////////////////
   //i sert a affecter un identifiant numérique à chaque état
   int i = 0;
   //Pour chaque état
   foreach(descetats.etatRow m_etat in m_descEtats.etat)
   {
    TRmenu = new HtmlTableRow();
    TDmenu = new HtmlTableCell();
    //On crée dynamiquement un lien qui passera le numéro de l'état en paramètre
    TDmenu.InnerHtml ="<a href=\"?etat=" + i + "\">" + m_etat.libcourt.ToString() + "</a>";
    TRmenu.Cells.Add(TDmenu);
    menu.Rows.Add(TRmenu);
    i++;
   }

   /////////////////////////////////////////////////////////////////
   ///Chargement des controles utilisateurs en fontion de l'état////
   /////////////////////////////////////////////////////////////////
   ///Si on a un paramètre "état" dans l'url, on a cliqué sur un lien du menu
   ///donc on charge les contrôles associés à l'état sélectionné
   if (Request.Params["etat"]!=null)
   {
                PanelOptions.Visible=true;
    int m_indexEtat = System.Convert.ToInt32(Request.Params["etat"]);
    //Pour chaque contrôle de l'état sélectionné
    foreach(descetats.controlRow m_descControle in m_descEtats.etat[m_indexEtat].GetcontrolRows())
    { 
     //On charge les contrôles
     this.placeControls.Controls.Add(ControlFactory.LoadControlEtat(m_descControle,this));
    }
    //On change le titre de la page qu'on remplace par le liblong de l'état
    this.TitrePage.Text = m_descEtats.etat[m_indexEtat].liblong;
   }
  }
#region Code généré par le Concepteur Web Form
 override protected void OnInit(EventArgs e)
 {
  //
  // CODEGEN : Cet appel est requis par le Concepteur Web Form ASP.NET.
  //
  InitializeComponent();
  base.OnInit(e);
 }
  
 /// <summary>
 /// Méthode requise pour la prise en charge du concepteur - ne modifiez pas
 /// le contenu de cette méthode avec l'éditeur de code.
 /// </summary>
 private void InitializeComponent()
 {    
  this.Load += new System.EventHandler(this.Page_Load);
 }
#endregion
 }
}

VI. Création d'un dataset fortement typé de comptoir.mdb

• Créer une nouvelle connexion de données sur comptoir.mdb dans la fenêtre "explorateur de serveurs" : clic droit sur connexion de données => ajouter une connexion
• Ajouter un dataset fortement typé au projet : dans l'explorateur de solution, sur le projet "EtatsMetier" => clic droit sur le projet => Ajouter => Ajouter un nouvel élément => Dataset. On l'appellera "DataEtats.xsd"
• Dans l'explorateur de serveur, développer l'arbre de la connexion à la base Access => développer Tables => Glisser/Déposer toutes les tables dans le concepteur de dataset.

Dataset fortement typé de comptoir.mdb

Ici, nous n'avons pas besoin de recréer les relations entre les tables : les clés des différentes tables sont correctement nommées donc Crystal Reports se chargera de faire le liaisons en fonction du nom des champs.

VII. Extraction des données

Reprenons notre schéma de départ :

Pour l'instant, nous avons les critères qui vont être saisis avec nos contrôles utilisateurs web et le conteneur de nos données qui sera le dateset fortement typé que nous venons de créer DataEtats. Nous allons maintenant créer une classe "ExtractionDataEtats" qui ne contiendra que des méthodes statiques lesquelles prendront en paramètre le résultat des saisies sur les différents contrôles utilisateurs.

Nous allons ajouter un nouveau fichier de type "ClassComponment" à notre projet "MetierEtats". Nous l'appellerons "gestData.cs".
Nous allons créer rapidement quatre adapters pour remplir les tables "Employés", "Produits", "Commandes" et "Détails commandes" en faisant un drag & drop de OleDbDataAdapter sur le designer. On suit les étapes du wizard et on génère le code pour remplir ces trois tables. On obtient donc ceci :

GestData.cs
  public DataEtats FillEmploye(DataEtats dataEtats, int numEmploye)
  {
   //On rajoute une clause where à la requete select pour ne selectionner que les employés voulus
   this.AdapterEmployes.SelectCommand.CommandText+=" WHERE [N° employé]=?";
   this.AdapterEmployes.SelectCommand.Parameters.Add("numEmp",numEmploye);
   this.AdapterEmployes.Fill(dataEtats);
   return(dataEtats);
  } 
  public DataEtats FillCommandesByPeriode(DataEtats dataEtats, Periode periode)
  {
   //On rajoute une clause where à la requete select pour ne selectionner que la période voulue
   this.AdapterCommandes.SelectCommand.CommandText+=" WHERE [Date commande]>=? AND [Date commande]<=?";
   this.AdapterCommandes.SelectCommand.Parameters.Add("dateD",periode.DateD);
   this.AdapterCommandes.SelectCommand.Parameters.Add("dateF",periode.DateF);
   this.AdapterCommandes.Fill(dataEtats);
   return(dataEtats);
  }
  public DataEtats FillAllProduits(DataEtats dataEtats)
  {
   this.AdapterProduits.Fill(dataEtats);
   return(dataEtats);
  }
  public DataEtats FillAllDetailsCommandes(DataEtats dataEtats)
  {
   this.AdapterDetailCommandes.Fill(dataEtats);
   return(dataEtats);
  }

ExtractionDataEtats.cs
using System;

namespace EtatsMetier
{
 /// <summary>
 /// Description résumée de ExtractionDataEtats.
 /// </summary>
 public class ExtractionDataEtats
 {
  public static DataEtats GetEmployeCommandByPeriode(int numEmploye, Periode periode)
  {
   //on instancie la classe qui va remplir le dataset
   gestData m_gestData = new gestData();
   //on instancie un dataset fortement typé
   DataEtats m_dataEtats = new DataEtats();
   m_dataEtats = m_gestData.FillEmploye(m_dataEtats,numEmploye);
   m_dataEtats = m_gestData.FillCommandesByPeriode(m_dataEtats,periode);
   m_dataEtats = m_gestData.FillAllProduits(m_dataEtats);
   m_dataEtats = m_gestData.FillAllDetailsCommandes(m_dataEtats);
   return (m_dataEtats);
  }
 }
}

VIII. Création d'un état

Lors du choix de la source de données, nous choisirons biensûr le dataset "DataEtats" :





Nous allons sélectionner les tables : "Employés", "Produits", "Commandes" et "Détails commandes".

Comme promis, Crystal Reports retrouve les relations entre les tables :

Une fois l'état créé, dans les propriétés de l'état, mettre "Action de génération" à "Aucun" :

IX. Génération de l'état

Default.aspx
<asp:panel id="PanelOptions" runat="server" Visible="false">
 <TABLE>
  <TR>
   <TD>
    <asp:button id="btnGenerer" Runat="server" Text="Générer l'état"></asp:button></TD>
  <TD :
   <asp:DropDownList id="ddlFormat" Runat="server">
    <asp:ListItem Value="pdf">pdf</asp:ListItem>
    <asp:ListItem Value="word">word</asp:ListItem>
    <asp:ListItem Value="excel">excel</asp:ListItem>
   </asp:DropDownList>
 </TD>
  </TR>
 </TABLE>
 <BR>
</asp:panel>

PanelOptions.Visible=true;

if (Request.Params["etat"]!=null)
 {

Maintenant nous avons deux options
• Soit nous générons le document dans Default.aspx.
  
• Soit la génération de document se fait dans une nouvelle fenêtre que nous ouvrirons.

Default.aspx.cs
private void btnGenerer_Click(object sender, System.EventArgs e)
 {
          
 int i=0;
 //pour chaque contrôle du placeholder
 foreach (IControlEtat m_controle in placeControls.Controls)
 {
  //On ajoute le couple Propriété à mapper/valeur en session
  HttpContext.Current.Session.Add(i.ToString(),m_controle.GetData());
  i++;
 }
 //on crée l'url en passant en paramètre l'état + le format de sortie
 string url=@"\genetat.aspx?etat=" + Request.Params["etat"].ToString();
 url+="&format=" + this.ddlFormat.SelectedValue;
 //on ouvre une nouvelle fenetre dans le navigateur
 Response.Write("<body><script>window.open(\" + url + "\",\"_blank\");</script></body>");
}

genetat.aspx.cs
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Reflection;
using System.IO;
using EtatsMetier;

namespace Etats
{
 /// <summary>
 /// Description résumée de genetat.
 /// </summary>
 public class genetat : System.Web.UI.Page
 {
  //Etat Crystal Reports
  protected CrystalDecisions.CrystalReports.Engine.ReportDocument m_report;
  //Description des etats
  private descetats m_descEtats;
  //Dataset fortement typé représentant les données de notre état
  private DataEtats m_dataEtats;
  //Index de l'état sélectionné
  private int m_indexEtat;
  //Nombre de paramètres en session
  private int nbrParam;
  //Liste des paramètres de la méthode d'extraction
  private object[] listeParam;

  private void Page_Load(object sender, System.EventArgs e)
  {
   //On récupère l'index de l'état passé en paramètre
   m_indexEtat = System.Convert.ToInt32(Request.Params["etat"]);
   //On récupère le descriptif des états
   m_descEtats = DescEtatsFactory.GetEtatDesc();
   //On compte le nombre de paramètres en session
   nbrParam = HttpContext.Current.Session.Keys.Count;
   //on initialise la liste de paramètres en conséquence
   listeParam = new object[nbrParam];
  
   int i;
   //On remplit la liste de paramètres
   for (i=0;i<nbrParam;i++)
   {
    listeParam[i] = HttpContext.Current.Session[i];
   }
   //On vide la session
   HttpContext.Current.Session.Clear();
   //On localise la méthode dans ExtractionDataEtats grâce à son nom défini
   //dans la balise methodgetdata de notre fichier xml
   Type t = typeof(ExtractionDataEtats);
   MethodInfo m = t.GetMethod(m_descEtats.etat[m_indexEtat].methodgetdata);
   //On invoque la méthode et on lui passe en paramètre la liste des objets de session
   //On récupère donc les données extraites dans notre dataset
   m_dataEtats = (DataEtats)m.Invoke(null,listeParam);
   //On instancie l'état
   m_report = new CrystalDecisions.CrystalReports.Engine.ReportDocument();
   //On charge l'état en fonction du chemin défini dans la balise pathreport
   //du fichier xml
   m_report.Load(HttpContext.Current.Request.PhysicalApplicationPath + m_descEtats.etat[m_indexEtat].pathreport);
   //On passe la source de données à l'état
   m_report.SetDataSource(m_dataEtats);

   //Création du flux au format souhaité
   MemoryStream m_stream = new MemoryStream();
   if(Request.Params["format"]=="excel")
    m_stream = (MemoryStream)m_report.ExportToStream(CrystalDecisions.Shared.ExportFormatType.Excel);   
   else if (Request.Params["format"]=="word")
    m_stream = (MemoryStream)m_report.ExportToStream(CrystalDecisions.Shared.ExportFormatType.WordForWindows);
   else
    m_stream = (MemoryStream)m_report.ExportToStream(CrystalDecisions.Shared.ExportFormatType.PortableDocFormat);

   //Envoi du flux 
   Response.Clear();
   Response.Buffer = true;
   if(Request.Params["format"]=="excel")
    Response.ContentType = "application/vnd.ms-excel";
   else if (Request.Params["format"]=="word")
    Response.ContentType = "application/doc"; 
   else
    Response.ContentType = "application/pdf";
 
   Response.BinaryWrite(m_stream.ToArray()); 
  }

  #region Code généré par le Concepteur Web Form
  override protected void OnInit(EventArgs e)
  {
   //
   // CODEGEN : Cet appel est requis par le Concepteur Web Form ASP.NET.
   //
   InitializeComponent();
   base.OnInit(e);
  }
  
  /// <summary>
  /// Méthode requise pour la prise en charge du concepteur - ne modifiez pas
  /// le contenu de cette méthode avec l'éditeur de code.
  /// </summary>
  private void InitializeComponent()
  {    
   this.Load += new System.EventHandler(this.Page_Load);
  }
  #endregion
 }
}

descetats.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<descetats xmlns="http://tempuri.org/descetats1.xsd">
 <etat>
  <libcourt>Bilan Commandes</libcourt>
  <liblong>Bilan des commandes par employé et par période</liblong>
  <pathreport>EtatsCR\Etat1.rpt</pathreport>
  <methodgetdata>GetEmployeCommandByPeriode</methodgetdata>
  <control>
   <Libcontrol>un employés :</Libcontrol>
   <pathcontrol>Controles/CtrlDDLEmploye.ascx</pathcontrol>
  </control>
  <control>
   <Libcontrol>une période :</Libcontrol>
   <pathcontrol>Controles/CtrlPeriode.ascx</pathcontrol>
  </control>
 </etat>
</descetats>

Les dates des commandes de la base comptoir.mdb sont comprises entre l'année 1996 et l'année 1998.

X. Ajouter un nouvel état sans recompiler le projet

descetats.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<descetats xmlns="http://tempuri.org/descetats.xsd">
 <etat>
  <libcourt>Bilan Commandes</libcourt>
  <liblong>Bilan des commandes par employé et par période</liblong>
  <pathreport>EtatsCR\Etat1.rpt</pathreport>
  <methodgetdata>GetEmployeCommandByPeriode</methodgetdata>
  <control>
   <Libcontrol>un employés :</Libcontrol>
   <pathcontrol>Controles/CtrlDDLEmploye.ascx</pathcontrol>
  </control>
  <control>
   <Libcontrol>une période :</Libcontrol>
   <pathcontrol>Controles/CtrlPeriode.ascx</pathcontrol>
  </control>
 </etat>
 <etat>
  <libcourt>Bilan Commandes 2</libcourt>
  <liblong>Bilan des commandes par employé et par période 2</liblong>
  <pathreport>EtatsCR\Etat2.rpt</pathreport>
  <methodgetdata>GetEmployeCommandByPeriode</methodgetdata>
  <control>
   <Libcontrol>un employés :</Libcontrol>
   <pathcontrol>Controles/CtrlDDLEmploye.ascx</pathcontrol>
  </control>
  <control>
   <Libcontrol>une période :</Libcontrol>
   <pathcontrol>Controles/CtrlPeriode.ascx</pathcontrol>
  </control>
 </etat>
</descetats>

XI. Critiques et améliorations de la solution proposée

1. Les controles utilisateurs web

2. L'extraction des données

L'accés aux données est un peu le "maillon faible" de notre portail. Mais comme je l'ai dit précédemment, cette partie mériterait à mon avis un article à elle seule.
Je vous conseille tout d'abord d'utiliser un composant d'accés aux données qui vous permettra de factoriser tout le code répétitif dès que l'on veut utiliser une requête. Je vous conseille l'article de R. Chapuis :  Construire un composant d'accès aux données.

• Soit en totalité.
• Soit en fonction d'une liste de contraintes sur des champs placés dans la clause Where de la rêquete select.
• Soit en fonction des enregistrements chargés dans une table "père".
• Soit en fonction d'une liste de contraintes et des enregistrements de la table "père"

3. Utilisation de Crystal Reports

Pourquoi ai-je utilisé Crystal Reports ? Tout d'abord rappellons que Crystal Reports est livré avec Visual Studio.NET et peut être utilisé en production aprés un enregistrement gratuit sur le site de  Business Objects. Comme vous avez pu le voir l'essentiel de l'article n'est pas la génération du rapport en elle-même étant donné que la création de l'état prend moins de 5 min (pour un état simple) et que la génération proprement dite prend à peinne quelques lignes de code une fois que l'on a rempli notre DataSet.
Donc l'argument qui a le plus orienté mon choix vers Crystal Reports est la productivitée. Biensûr on peut générer du pdf, du word et du excel sans Crystal Reports, mais pas aussi facilement.
Coté performances, Crystal Reports utilise une mise en cache intelligente des états générés et l'ensemble de l'application supporte bien la montée en charge. J'ai fait des test de montée en charge sur une application de production et j'ai été agréablement surpris. Je ne vous donnerais pas de chiffres de bench qui seraient insignifiants mais pour générer un rapport pdf de 60 pages avec plus de 2 000 utilisateurs simultanés, l'ouverture d'Acrobat Reader et l'envoi du pdf prennent plus de temps que la génération de celui-ci. Par contre, prévoyez un serveur dédié car la génération consomme pas mal de ressources CPU sur votre serveur.

Le seul inconvénient de Crystal Reports va être le déploiement, pas toujours évident mais quand on a pris le coup de main, on finit par y arriver assez facilement. Je vous propose de lire :  Déploiement d'un état Crystal Reports pour plus d'informations. L'article parle du déploiement d'applications windows mais le déploiement web est similaire.

4. Gestion des exceptions

Conclusion