A bord de Salamanca

Aller au contenu | Aller au menu | Aller à la recherche

Alpha 2 : les énumérations

La sortie de la version alpha 2 de Salamanca nous a donné l'occasion de sortir notre équipement pour révision en cale sèche...

Spécification du cycle de vie d'un projet

La principale amélioration apportée par Salamanca alpha 2 étant le support des énumérations dans le modèle entité, nous en avons profité pour revoir et implémenter le cycle de vie d'un projet suivant :

Projet_LifeCycle 

Chaque changement de statut est de la responsabilité d'un des interlocuteurs que nous avons déjà spécifié lors de la modélisation de nos entités :

  • Un client soumet un projet
  • Un commercial prend en charge ou annule un projet soumis
  • Le client détaille le besoin de son projet pris en charge
  • Un consultant prototype un périmètre délimité du besoin
  • Le client clôture le projet après livraison du prototype

Modélisation avec énumération

Pour modéliser le cycle de vie d'un projet, nous avons ajouté l'énumération StatutProjet dans notre modèle entité et défini chaque statut du cycle en tant que valeur, avec comme type sous-jacent une chaîne de 5 caractères. Nous avons alors ajouté l'attribut Statut à l'entité Projet et défini son type comme StatutProjet.

VS_Model_StatutProjet

Pour chaque valeur d'énumération, nous associons à travers le champ Description de ses propriétés la chaîne de caractères "en français" : Soumis, Pris en charge, Détaillée, Prototypé, Clôturé, Annulé.

On retrouve alors dans le code SQL généré l'insertion de ces valeurs en base :

INSERT INTO StatutProjet VALUES('SOUMI', 'Soumis');
INSERT INTO StatutProjet VALUES('ENCHA', 'Pris en charge');
INSERT INTO StatutProjet VALUES('DETAI', 'Détaillé');
INSERT INTO StatutProjet VALUES('PROTO', 'Prototypé');
INSERT INTO StatutProjet VALUES('CLOTR', 'Clôturé');
INSERT INTO StatutProjet VALUES('ANNUL', 'Annulé');

Implémentation de l'écran liste des projets

Afin d'avoir une vue d'ensemble des projets client, un commercial doit pouvoir visualiser la liste des projets et leur statut dés la page d'accueil de son espace.

Nous ajoutons donc dans le projet Eproject.Web :

  • un répertoire Espace qui regroupe les écrans accessibles après ouverture de session
  • une page d'accueil Default.aspx qui affiche une vue d'ensemble selon le rôle utilisateur

Dans la page d'accueil, nous implémentons la liste des projets à travers :

  • un contrôle ASP.NET GridViewaffichant les projets sous forme de tableau
  • un contrôle ASP.NET SqlDataSource récupérant les informations directement avec une requête SQL vers la base de données

Pour accéder à la base de données, nous configurons une chaîne de connexion avec l'utilitaire Enterprise Library Configuration de la même façon que pour notre projet de tests unitaires. Le résultat placé dans le fichier web.config du projet web est le suivant :

<dataConfiguration defaultDatabase="eProject_ABord" />
<connectionStrings>
  <add name="eProject_ABord" connectionString="Data Source=.\SQLEXPRESS;Initial Catalog=eProject_ABord;Integrated Security=True" providerName="System.Data.SqlClient" />
</connectionStrings>

Pour alimenter la liste, nous ajoutons des données de test dans la base eProject_ABord avec le script SQL :

Declare @client_id uniqueidentifier=newid();

INSERT INTO Interlocuteurs (Id, Nom, Email) VALUES (@client_id, 'Client test', 'client@test.com');
INSERT INTO Clients (Id, Societe) VALUES (@client_id, 'Société test');

INSERT INTO Projets (Client_Id, Nom, Statut_Code) VALUES (@client_id, 'Application DA VINCI', 'SOUMI');
INSERT INTO Projets (Client_Id, Nom, Statut_Code) VALUES (@client_id, 'Gestion de stocks', 'SOUMI');
INSERT INTO Projets (Client_Id, Nom, Statut_Code) VALUES (@client_id, 'Projet SIGMAT', 'ENCHA');
INSERT INTO Projets (Client_Id, Nom, Statut_Code) VALUES (@client_id, 'Plateforme YaKa', 'DETAI');
INSERT INTO Projets (Client_Id, Nom, Statut_Code) VALUES (@client_id, 'Fiche PATROL', 'PROTO');
INSERT INTO Projets (Client_Id, Nom, Statut_Code) VALUES (@client_id, 'MOBILAT', 'CLOTR');
INSERT INTO Projets (Client_Id, Nom, Statut_Code) VALUES (@client_id, 'Projet SPAMMER', 'ANNUL');

Dans un fichier de ressource nommé Sql.resx ajouté au dossier ASP.NET App_GlobalResources, nous définissons la requête SQL ProjectSelectList :

SELECT p.Id, p.Client_Id, p.Nom, c.Societe, sp.Description
FROM Projets p, Clients c, StatutProjet sp
WHERE  p.Client_Id=c.Id AND p.Statut_Code=sp.Code

Dans la page web, nous ajoutons le code ASP.NET ci-dessous pour afficher la liste issue de la requête :

<asp:SqlDataSource ID="ProjetSqlDataSource" runat="server" 
ConnectionString="<%$ ConnectionStrings:eProject_ABord %>" ProviderName="<%$ConnectionStrings:eProject_ABord.ProviderName %>"
SelectCommand="<%$ Resources:Sql, ProjetSelectList %>">
</asp:SqlDataSource>
<asp:GridView ID="ProjetGridView" runat="server" DataSourceID="ProjetSqlDataSource" DataKeyNames="ID" Width="400px">
    <Columns>
        <asp:BoundField DataField="Id" HeaderText="Id" ReadOnly="True" SortExpression="ID" Visible="False" />
        <asp:BoundField DataField="Nom" HeaderText="<%$ Resources:SR, ProjetNomLabel %>" />
        <asp:BoundField DataField="Societe" HeaderText="<%$ Resources:SR, ClientSocieteLabel %>" />
        <asp:BoundField DataField="Description" HeaderText="<%$ Resources:SR, ProjetStatutLabel %>" />
    </Columns>
</asp:GridView>

Pour obtenir un "look & feel" homogène dans notre application, nous avons ajouté :

  • la page maître Site.Master liée à une feuille de style CSS placée dans le thème Default du répertoire ASP.NET App_Themes
  • un fichier d'apparence grid.skin également placé dans le thème Default définissant le style par défaut d'un contrôle GridView
  • l'option styleSheetTheme="Default" à la directive pages du fichier web.config

La page Default.aspx est transformée en formulaire de contenu web en ajoutant :

  • la directive MasterPageFile="~/Site.master"
  • le code ASP.NET dans un contrôle Content associé à la région pour le contenu (ContentPlaceHolder) définie dans la page maître

Nous obtenons ainsi la liste des projets avec leur client et leur statut associés sous la forme suivante :

 Ecran Liste des projets client

Mise à jour des références Salamanca

Le refactoring des bibliothèques réalisé dans la mise à jour alpha 2 de Salamanca nous a permis lors de cette révision de réduire le nombre de références dans notre projet.

Par exemple, dans le projet Eproject.Model, nous avions les 4 références suivantes :

  • Salamanca.Common
  • Salamanca.DataAccess
  • Salamanca.DataAccess.EnterpriseLibrary
  • Salamanca.DataRules

Nous n'avons maintenant plus que 2 références :

  • Salamanca
  • Salamanca.EnterpriseLibrary.4

Ce passage en "révision" de notre équipée nous a donc permis d'enrichir notre modèle graphique des entités avec la description du cycle de vie d'un projet ainsi que que de l'illustrer simplement à travers l'implémentation d'un écran web accédant directement à la base de données.

Il est bientôt temps de repartir à l'aventure pour mettre en oeuvre des interactions entre l'application et l'utilisateur à travers des activités métier...

Contrôle des papiers...

En quittant notre dernière escale, nos hôtes nous ont demander de présenter des informations validées sur notre équipée. Heureusement, nous avons dans Salamanca une bibliothèque qui permet de vérifier aisément la saisie de données : Data Rules !

Pour rendre un système d'information utile et efficace, il ne suffit pas de l'alimenter en données, il faut aussi en assurer la cohérence.

La première exigence qui en découle est de valider les informations fournies si possible dés leur saisie et avant leur sauvegarde dans la base de données.

Dans le modèle entité dessiné avec Salamanca, on peut associer à chaque attribut des règles de validation prédéfinies en fonction de spécifications métier telles que :

  • valeur par défaut ; par exemple, le statut du projet est "Nouveau" par défaut
  • autorisation de la valeur null ; par exemple, un projet doit avoir un nom
  • longueur maximum ; par exemple, le nom du projet ne dépasse pas 32 caractères
Ces propriétés sur les attributs d'une entité constituent le premier niveau de règles métier. Elles sont implémentées non seulement dans la base de données sous forme de contraintes, mais aussi dans la couche objet sous forme d'attributs (au sens .NET) liés aux propriétés de l'objet. Par exemple :
[NotNullRule]
[StringLengthRule(32)]
public string Nom
{
...
}

Profitons d'avoir configuré notre projet de tests pour valider que ces règles métier sont vérifiées lors de la sauvegarde d'un projet.

Pour faciliter l'exécution de notre série de tests, nous initialisons chacun avec des données valides pour une instance de Projet défini pour la classe de test :

[TestInitialize()]
public void MyTestInitialize()
{
Client c = new Client(DataMappers);
c.Nom = "Jean Dupond";
Projet = new Projet(c, DataMappers);
Projet.Nom = "Mon projet";
}

Pour tester que le nom saisi dépasse la longueur maximale, nous ajoutons un test avec "un nom de projet vraiment trop long" et nous vérifions que

  • la méthode Validate(string propertyName) d'un objet DomainEntity renvoit FAUX
  • qu'une BrokenRulesException est levée lorsqu'on sauvegarde une instance non valide
[TestMethod]
[ExpectedException(typeof(BrokenRulesException))]
public void CannotValidateNomNull()
{
    Assert.IsTrue(Projet.Validate());
    Projet.Nom = null;
    Assert.IsFalse(Projet.Validate("Nom"));
    Projet.Save();
}

Le code complet de notre classe se résume à la validation d'une série de 3 tests :

  • On doit pouvoir sauvegardé une instance de Projet avec un nom valide
  • On ne doit pas pouvoir sauvegardé une instance de Projet avec un nom vide (NULL)
  • On ne doit pas pouvoir sauvegardé une instance de Projet avec un nom trop long (> 32 caractères)
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Salamanca.DataRules;
using NourY.Eproject.Model;

namespace NourY.Eproject.Tests.Model
{
    [TestClass]
    public class ProjetTest : UnitTestBase, IProjetContainer
    {
        [TestMethod]
        [DeploymentItem("..\\eProject_ABord_Tests.mdf")]
        public void CanSaveAndValidateProjet()
        {
            Assert.IsTrue(Projet.Validate());
            Projet.Save();
        }

        [TestMethod]
        [ExpectedException(typeof(BrokenRulesException))]
        public void CannotValidateNomNull()
        {
            Assert.IsTrue(Projet.Validate());
            Projet.Nom = null;
            Assert.IsFalse(Projet.Validate("Nom"));
            Projet.Save();
        }

        [TestMethod]
        [ExpectedException(typeof(BrokenRulesException))]
        public void CannotValidateNomTooLong()
        {
            Assert.IsTrue(Projet.Validate());
            Projet.Nom = "Un nom de projet vraiment trop long";
            Assert.IsFalse(Projet.Validate("Nom"));
            Projet.Save();
        }

        [TestInitialize()]
        public void MyTestInitialize()
        {
            Client c = new Client(DataMappers);
            c.Nom = "Jean Dupond";
            Projet = new Projet(c, DataMappers);
            Projet.Nom = "Mon projet";
        }

        public Projet Projet
        {
            get { return _Projet; }
            set { _Projet = value; }
        }

        private Projet _Projet;
    }
}

Les règles de validation sur les attributs des entités s'avère donc non seulement aisées à mettre en place mais également implémentées de manière concise dans la couche objet. Pour valider des champs avec des règles avancées tels qu'une adresse email, un numéro de téléphone ou un code postal, nous pouvons exploité la puissance des expressions régulières à travers des règles de type RegexRule.

Cette exploration "forcée" de la bibliothèque DataRule entre deux escales nous ouvre déjà un horizon bien dégagé du côté de la consolidation des données de nos applications métier. A suivre avec leur utilisation dans le cadre d'activités métier...

Escale #3 : Tests unitaires

Nous avons maintenant une base de données à notre disposition. Mais ne perdons pas de vue le but de notre expédition, ou plutôt l'enchainement de buts : apprendre à utiliser Salamanca afin, in fine, de mettre en place un processus métier qui produit de la valeur.

Mais comme dans la fable du lièvre et de la tortue, nous prenons le temps de mettre en place des bonnes pratiques de développement en cours de route afin d'assurer à la fois la qualité de notre produit et la facilité de sa maintenance.

L'escale d'aujourd'hui s'attarde sur la mise en place des outils de contrôle de la qualité : les Tests.

Contexte

Même si nous parlons de tests unitaires, notre intention est plutôt de s'assurer que le code produit est conforme au résultat attendu, par exemple que les règles métier définies sont bien respectées. Dans la terminologie du test informatique, on parle alors de tests fonctionnels (de recette ou encore d'acceptation) par opposition aux tests techniques (unitaires, d'intégration, système, performance, ...).

Mais dans notre cas, nous nous appuyons sur le framework de test de Visual Studio. C'est pourquoi nous avons créé le projet Eproject.Tests lors de la mise en place de la solution (cf L'application Salamanca).

Configuration

Comme l'objet de notre application est de manipuler des données, nous avons besoin d'une base de données dédiée pour les tests qui puisse être recréée à chaque exécution d'un jeu de tests. Pour cela, nous procédons de la même manière que pour la base de données de développement, avec une étape supplémentaire :

  • création d'une base de données SQL Server 2008 Express
  • copie du fichier de base de données dans le projet de tests

Cette procédure peut se traduire sous forme de la commande batch CreateTests.cmd, placée dans le répertoire Create Scripts du projet Eproject.Sql :

SET CONNECT_STRING=.\SQLEXPRESS 
SET BASE_NAME=eProject_ABord_Tests
SET TestsDir=%CD%\..\..\Eproject.Tests

sqlcmd.exe -E -X -S %CONNECT_STRING% -v DatabaseName=%BASE_NAME% -i Create.sql

xcopy "C:\Program Files\Microsoft SQL Server\MSSQL10.SQLEXPRESS\MSSQL\DATA\%BASE_NAME%.mdf" %TestsDir% /y
xcopy "C:\Program Files\Microsoft SQL Server\MSSQL10.SQLEXPRESS\MSSQL\DATA\%BASE_NAME%_log.ldf" %TestsDir% /y

Une fois le fichier de base de données copié, nous l'ajoutons dans notre projet ("Afficher tous les fichiers", clic droit sur le fichier, puis "Inclure dans le projet").

La configuration de sa chaîne de connexion est facilité par l'utilisation du Data Application Block du framework Microsoft Enterprise Library (cf Pré-requis). Pour cela, nous utilisons :

  • un fichier de configuration app.config ajouté dans notre projet
  • l'utilitaire Enterprise Library Configuration

Enterprise Library Configuration

On obtient ainsi le code de configuration suivant :

<configuration> 
  <configSections>
    <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Data.Configuration.DatabaseSettings, Microsoft.Practices.EnterpriseLibrary.Data, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
  </configSections>
  <dataConfiguration defaultDatabase="eProject_ABord_Tests" />
  <connectionStrings>
    <add name="eProject_ABord_Tests" connectionString="data source=.\SQLEXPRESS;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|eProject_ABord_Tests.mdf;User Instance=true"
      providerName="System.Data.SqlClient" />
  </connectionStrings>
</configuration>

Codage

Pour pouvoir coder des tests qui manipulent des instances des entités métier que nous avons modélisé, nous aurons besoin d'une collection de DataMapper, dont le rôle (tel que je l'ai assimilé) est de servir de point d'ancrage de la couche de persistence, à savoir la gestion du cache et des échanges entre les instances d'objets en mémoire et leur structure de stockage en base de données (cf QuickStart : the Domain Model).

L'implémentation choisie est d'avoir une classe de base dont tous les tests hériterons. C'est une classe publique contenant une propriété de type DataMapperCollection avec un getter sous forme de singleton tirant parti des facilités offertes par les bibliothèques Enterprise Library et DataAccess pour créer une connexion avec la base de données (configurée par défaut dans app.config) ainsi qu'un mode de cache des données (dans notre cas, elles ne seront pas conservées en mémoire).

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Microsoft.Practices.EnterpriseLibrary.Data;
using Salamanca.DataAccess;
using Salamanca.DataAccess.Collections;
using NourY.Eproject.Model.Mappers.EnterpriseLibrary;

namespace NourY.Eproject.Tests
{
public class UnitTestBase
{
public UnitTestBase()
{
}

protected DataMapperCollection DataMappers
{
get
{
if (_DataMappers == null)
_DataMappers = Mappers.CreateDataMapperCollection(
DatabaseFactory.CreateDatabase(),
new NoCacheManager());
return _DataMappers;
}
}

private DataMapperCollection _DataMappers;
}

References

Pour pouvoir compiler notre projet, nous avons ajouté les références aux bibliothèques contenant les types utilisés dans notre classe de base :

  • DatabaseFactory dans EnterpriseLibrary.Data
  • NoCacheManager et DataMapperCollection dans DataAccess
  • Mappers dans Eproject.Model

 

Voici venu le temps de tester notre configuration à travers un exemple simple : je veux pouvoir sauvegarder le projet nommé "Projet Test" du client nommé "Client Test".

Nous ajoutons le test unitaire CrudProjetTest qui hérite de la classe UnitTestBase. Afin d'avoir une base de données "propre" à chaque exécution, nous l'associons à notre classe de test à travers l'attribut DeploymentItem.

    [TestClass]
[DeploymentItem("..\\eProject_ABord_Tests.mdf")]
public class CrudProjetTest : UnitTestBase
{
[TestMethod]
public void CanSaveProjet()
{
Client c = new Client(DataMappers);
c.Nom = "Projet Test";
Projet p = new Projet(c, DataMappers);
p.Nom = "Client Test";

Assert.IsTrue(p.IsModified);
p.Save();
Assert.IsFalse(p.IsModified);
}
}

Nous vous invitons à tester cette configuration dont le réel intérêt est à terme de pouvoir valider que l'implémentation des activités métier de notre application s'exécute avec succès et respectent les règles métier définis. Mais avant cela, nous verrons évidemment comment concevoir et coder les activités métier, concept essentiel de Salamanca...

Escale #2 : Base de données

Pourquoi avoir spécifié, modélisé et généré des entités métier ?

Si nous sommes à bord de Salamanca, c'est car nous voulons informatiser (et améliorer) l'un de nos processus de travail. L'objectif est de permettre aux acteurs de ce processus de consulter, saisir, évaluer, récupérer ou exploiter les ressources et informations alimentant ce processus dans le cadre d'un enchaînement d'activités.

C'est d'ailleurs la base de la définition d'une application métier :

"manipuler des données spécifiques à une organisation ou un secteur d'activité".

Nous sommes donc en accord avec la ligne de produits ciblée par l'usine Salamanca (ça tombe bien !). Pour cela, un moyen de stocker l'ensemble de ces informations nous est nécessaire.

Comme Salamanca comprend une bibliothèque ORM (mais pas seulement !), l'implémentation du mapping entre notre modèle d'entités métier et le modèle physique des données est pour nous, humble développeur "métier", transparent (même s'il est toujours conseillé d'avoir une compréhension haut niveau des concepts associés).

Nous nous attarderons donc lors de cette escale uniquement sur l'organisation que nous avons mis en place pour créer (et re-créer) rapidement notre base de données.

Organisation

Puisque nous disposons du code SQL généré pour la création des tables et des procédures stockées CRUD, autant en profiter. Néanmoins, leur emplacement dans le projet Model et leur liaison au fichier modèle (.tt) assurant leur génération ne permettent pas de les dinstinguer facilement dans notre solution Visual Studio. C'est pourquoi nous avons ajouté le projet Eproject.Sql de type Projet de base de données lors de la création de notre solution (tout s'explique !).

Ainsi, chaque développeur dispose de sa propre base de données de développement à partir d'un schéma placé dans le gestionnaire de versions (conformément aux bonnes pratiques) et "bien rangé" dans l'environnement de travail :

  • VS_SolutionExplorer_Sqlles scripts de création : dans Create Scripts
  • les scripts de mise à jour : dans Change Scripts

Pour cela, nous ajoutons dans les propriétés du projet Eproject.Model un évènement après génération (Post-build) afin de copier les fichiers SQL générés dans leur répertoire cible.

De cette façon, les scripts servant à la création de la base restent synchronisés après chaque mise à jour du modèle, puis compilation du code généré.

Remarque : la première fois, pensez à ajouter manuellement les fichiers copiés (clic droit sur le répertoire, puis "Ajouter un élément existant...").

Automatisation

Pour automatiser la création de notre base de données, nous avons besoin :

  • d'un script TRANSACT-SQL pour effacer (si nécessaire) et créer la base
  • d'exécuter l'utilitaire sqlcmd en ligne de commande ou dans un batch (.cmd)

Nous pourrions pousser l'automatisation de la même façon que pour la copie des fichiers SQL en ajoutant un évènement après génération du projet Eproject.Model. Mais cela efface les données saisies en cours de développement à chaque génération, donc nous préférons nous placer dans le répertoire Create Scripts et exécuter la commande ci-dessous (dans un batch) uniquement lors d'un changement dans notre schéma :

C:\eProject\src\ABordDeSalamanca\Eproject.Sql\Create Scripts>sqlcmd.exe -E -X -S .\SQLEXPRESS -v DatabaseName=eProject_ABord -i Create.sql

Comme nous utilisons une base de données SQL Server 2008 Express, notre exemple de script TRANSACT-SQL contient le code suivant :

USE master
GO

IF EXISTS (SELECT * FROM sys.databases WHERE name=N'$(DatabaseName)')
BEGIN
ALTER DATABASE $(DatabaseName)
SET SINGLE_USER
WITH ROLLBACK IMMEDIATE
DROP DATABASE $(DatabaseName)
END
GO

CREATE DATABASE $(DatabaseName)
GO

USE $(DatabaseName)
GO

:reset
:r Tables.sql
:r StoredProcedures.sql
GO

Voilà une façon rapide de disposer à tout moment d'une base de données synchronisée avec notre modèle d'entités métier. Et nous verrons lors de notre prochaine escale comment la mise en place de notre projet de tests unitaires en bénéficie...

Escale #1 : Entités métier

Entités

Nous voilà arrivés au pays des "entités". Mais qui sont-elles ?

Pour mieux intégrer cette notion d'entité, nous nous référons à sa définition dans le cadre du modéle entité-relation développé par Dr Peter Chen :

"une chose qui peut être identifiée distinctement ayant une signification pour une organisation".

Spécification

Dans le cadre du service que nous développons, eProject, nous voulons mettre en relation les entités suivantes :

  • un projet métier : vue d'ensemble, besoin détaillé et périmètre d'un prototype
  • 3 interlocuteurs : client, commercial et consultant

Lors de la définition de notre besoin, nous avons également précisé les règles d'association à travers les spécifications suivantes :

  • Pour consulter NourY Solutions sur mes besoins métier, je veux pouvoir soumettre mon projet ainsi que mes projets ultérieurs en tant qu'interlocuteur client
  • Pour piloter la relation clientèle, je prend en charge le suivi de l'avancement des projets de chacun de mes clients en tant qu'interlocuteur commercial
  • Pour produire un prototype à partir de l'analyse d'un besoin, je veux pouvoir estimer la charge de travail sur la base de chaque projet en tant qu'interlocuteur consultant

Modélisation

Modèle eProject

Une fois les concepts digérés et notre besoin spécifié, Salamanca nous permet de rapidement modéliser le socle de notre métier représenté dans le diagramme ci-dessus.

Pour cela, nous ouvrons le modèle SDML du projet Eproject.Model de la solution Visual Studio créée lors de notre départ.

VS_Model_Toolbox

La palette d'éléments mise à disposition dans la boite à outils est d'une aide précieuse pour implémenter notre modèle de 5 entités simplement par glisser-déposer et définition des propriétés des associations :

  • 1 composition entre Client et Projet
  • 2 associations bidirectionnelles entre Commercial et Client, entre Consultant et Projet 
  • 3 héritages : Client, Commercial et Consultant sont tous des Interlocuteurs du Projet

Nous pouvons maintenant définir les attributs soit par glisser-déposer de l'élément "Attribute" à partir de la boîte à outils, soit par clic droit sur l'entité, puis "Ajouter un nouveau Entity Attribute" à partir du menu contextuel.

Le nom et le type (string par défaut) de l'attribut peuvent être définis directement de manière graphique alors que la fenêtre de "Propriétés" permet également de spécifier des règles validées automatiquement grâce à l'utilisation de l'une des 4 bibliothèques de Salamanca : Data Rules

La facilité d'intégration de règles métier est l'une des grandes forces de Salamanca, aussi nous lui dédierons bientôt une escapade de découverte avant la prochaine escale !

Génération

Une fois les attributs et les règles associées définis pour chaque entité, il nous reste qu'à générer le code correspondant par un simple clic sur l'icône "Transformer tous les modèles" présente dans la barre d'outils de la fenêtre "Explorateur de solutions".

Code généré

A la fin de la génération, nous obtenons l'ensemble du code de la couche d'accès aux données basé sur la bibliothèque générique de Salamanca dédié à cet usage : Data Access. Cette couche est constituée :

  • du code SQL de création des tables associées aux entités
  • des procédures stockées pour les opérations CRUD sur chaque entité
  • des interfaces et classes de mapping entre entités et tables (Data Mappers)
  • des ressources liant procédures stockées et méthodes CRUD implémentées dans les Data Mappers
  • des interfaces et classes des entités du domaine métier

L'avantage évident de cette formule "Modélisation + Génération" est de ne plus avoir à taper du code redondant. Pour preuve, je vous invite à satisfaire votre curiosité et éditer les fichiers générés : on retrouve le même air dans chaque classe avec quelques variations autour du thème...

Mais le réel instant de bonheur du point de vue du développeur se savoure lors de l'implémentation de demandes d'évolutions telles que l'ajout d'attributs, ou mieux, lors de la modification de relations. Personnellement, j'ai par le passé consommé beaucoup de temps dans la maintenance du code SQL et objet suite aux évolutions inhérentes à tout projet métier.

Je vous invite donc dés maintenant à faire l'expérience avec le modèle métier de votre projet en cours avant notre prochaine escale : l'automatisation de la mise en place de la base de données.

Larguez les amarres !

Au moment de larguer les amarres, il y a toujours sur le quai un ami ou un passant pour nous demander si rien n'a été oublié et que tout a été chargé...

Pré-requis

Pour démarrer, nous avons bien sûr téléchargé la dernière version 1.0 (alpha) de Salamanca à l'adresse :

http://salamanca.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=24562

Suivant le manuel d'installation, nous avons d'abord vérifié que notre équipement contient déjà Visual Studio 2008 SP1 dont la version d'évaluation de l'édition Professionnal est téléchargeable à l'adresse :

http://www.microsoft.com/downloads/details.aspx?familyid=83C3A1EC-ED72-4A79-8961-25635DB0192B&displaylang=fr

Nous avons ensuite téléchargé et installé les Guidance Automation Extensions (GAX) à l'adresse :

http://www.microsoft.com/downloads/details.aspx?familyid=DF79C099-4753-4A59-91E3-5020D9714E4E

Comme nous souhaitons utiliser les facilités offertes par le Data Access Application Block, nous avons aussi téléchargé Enterprise Library 4.1 à l'adresse :

http://www.microsoft.com/Downloads/details.aspx?familyid=1643758B-2986-47F7-B529-3E41584B6CE5

Nous utiliserons également une base de données SQL Server 2008 Express disponible avec l'outil SQL Server 2008 Management Studio Express à l'adresse :

http://www.microsoft.com/downloads/details.aspx?displaylang=fr&FamilyID=7522a683-4cb2-454e-b908-e805e9bd4e28

L'application Salamanca

Nous voilà parés pour monter à bord de Salamanca. Notre périple commence par la création de notre application eProject dans notre environnement de développement Visual Studio.

Salamanca Application 

Nous respectons ensuite (presque) les conventions de nommage de mise en majuscule de notre langage préféré C# dans la définition du nom de domaine de l'application.

Salamanca Application Information  

Explorateur de solutions

Nous obtenons ainsi une solution Visual Studio constituée du projet Eproject.Model de type Bibliothèque de classes qui nous permettra de modéliser les concepts métier de notre application et de générer l'ensemble du code associé :

  • classes des entités métier
  • classes de mapping objet-relationnel (DataMappers)
  • scripts SQL de création des tables et procédures stockées de la base de données

Afin d'avoir les provisions nécessaires à notre voyage, nous ajoutons dés maintenant à la solution Visual Studio les projets pour chaque composant à fabriquer. Notre application Salamanca est alors composée de :

  1. Eproject.Model de type Bibliothèque de classes pour la modélisation et la génération des entités métier
  2. Eproject.Sql de type Projet de base de données pour la création et maintenance des scripts SQL
  3. Eproject.Tests de type Projet de test pour la création et l'exécution des tests unitaires
  4. Eproject.Activities de type Bibliothèque de classes pour le codage des activités métier
  5. Eproject.Web de type Application Web ASP.NET contenant l'implémentation web des activités ainsi que la définition de la présentation à travers :
    • une page maître
    • un thème ASP.NET
    • les ressources de localisation
  6. Eproject.Setup de type Projet d'installation Web pour le déploiement de l'application

Structure de base Subversion

Nous ajoutons l'arborescence des fichiers créés à partir de cette structure de base dans notre gestionnaire de versions (Subversion) qui sert de référentiel pour l'ensemble de nos codes sources.

Nous voilà munis d'un équipement bien outillé et d'un bel horizon devant nous.

Sun behind cloud

Lors de notre prochaine escale, vous verrez comment nous tirons profit du bon vent que nous amène la modélisation des entités et la génération du code associé.

Tâchons de garder le cap !

Bye bye World!

Fidèle à la politesse légendaire des outils de développement, nous commençons donc par une sorte de "Bonjour Monde !" (ça sonne bizarre en français...) transformé dans notre cas en "Au revoir Monde !" car c'est un nouvel univers que nous prenons en main avec Salamanca.

Voici venue l'heure de faire un tour de chauffe et de voir comment se comporte notre embarcation à travers un prototype de notre application web développée suivant 2 approches :

  • un formulaire ASP.NET
  • une question dans une activité Salamanca
Dans l'application web métier qui sert de fil conducteur à ce carnet de bord, l'utilisateur va principalement manipuler des projets. L'activité initiale à l'origine de l'ensemble du processus a été spécifiée sous la forme suivante :

En tant que donneur d'ordre, je veux pouvoir soumettre un projet en ligne afin de décrire un besoin métier en un minimum de temps.

Formulaire ASP.NET

ASP.NET FormView Un formulaire web peut être rapidement assemblé dans Visual Studio à partir d'une table dans une base de données SQL Express et des contrôles ASP.NET FormView, SqlDataSource.

CREATE TABLE Projets(
Id int IDENTITY(1,1) NOT NULL,
Titre nvarchar(255) NOT NULL,
Description ntext NOT NULL,
...
)
<asp:FormView ID="_FormView" runat="server" DataKeyNames="Id" DataSourceID="_SqlDataSource"> ...
</asp:FormView>
<asp:SqlDataSource ID="_SqlDataSource" runat="server" ConnectionString="<%$ ConnectionStrings:Proto %>" > ...
</asp:Sqldatasource>

Grâce à l'environnement et aux outils mis à notre disposition par Microsoft, nous pouvons donc aller très vite pour "assembler" un écran qui pourrait satisfaire l'exigence métier. Par contre, pour satisfaire nos attentes et disposer d'une application robuste, modulaire et maintenable, c'est moins certain... Par exemple, maintenir toutes les requêtes SQL inclues directement dans la page web s'avère rapidement consommateur d'énergie lorsqu'on fera évoluer le modèle de données.

Question Salamanca

Ce que nous avons retenu de l'usine à logiciels Salamanca, c'est l'introduction du concept d'activité métier pour répondre à la problématique de séparation entre les 3 couches : Présentation - Métier - Accès aux données. Une activité s'exécute à partir de données définies dans un modéle objet et interagit avec l'utilisateur à travers des questions auxquelles sont associées des écrans.

Nous avons ainsi conçu le modèle d'activité suivant pour satisfaire l'exigence spécifiée :

Activité Soumettre un Projet

Dans le diagramme de notre activité ci-dessus, nous avons :

  • un état qui pose une question à l'utilisateur : AskProjetInfos
  • deux états de traitement : CreateProjet, SaveProjet
  • un conteneur des données manipulées : Data

Nous verrons lors d'une prochaine escale comment les entités métier constituant les données de l'activité sont modélisées et le code des classes comme des tables associées sont générées.

Notre but ici est de faire le parallèle avec le prototype de formulaire ASP.NET, donc d'introduire comment est implémentée la présentation du même écran.

Lors son exécution, l'activité fournit la référence au projet créé dans la question invitant l'utilisateur à saisir les informations de description de son nouveau projet. On peut alors directement lier l'interface homme-machine avec l'instance de l'entité métier chargée de la persistence des informations.

Plutôt que d'étendre le contrôle FormView pour y inclure la référence à l'entité, nous préférons implémenter un contrôle utilisateur nommé ProjetEditor qui pourrait être généré à l'avenir par notre usine à partir du modèle objet.

<uc1:ProjetEditor ID="_ProjetEditor" runat="server" />
public partial class ProjetEditor : UserControl, IProjetContainer

Dans l'écran associé à la question, nous déclarons comme éléments visuels :

  • le contrôle utilisateur : ProjetEditor
  • deux boutons pour valider ou annuler la saisie : NextButton, CancelButton

La page ASP.NET implémente également l'interface contenant l'entité à manipuler :

public partial class ProjetAskInfos : Page, IProjetContainer

Et le lien avec le contrôle utilisateur "coule de source" :

public Projet Projet
{
get { return _ProjetEditor.Projet; }
set { _ProjetEditor.Projet = value; }
}

Il nous reste à brancher le contrôleur qui gère l'exécution de l'activité :

private IActivityController ActivityController
{
get { return ActivityControllersSessionStack.Instance.Peek(); }
}

Ce qui est fait à chaque chargement de la page :

protected void Page_Load(object sender, EventArgs e)
{
ActivityController.Execute();
}

Enfin, à travers les évènements déclenchés par un clic sur les boutons, le contrôleur assure le passage à l'état suivant ou l'annulation de l'activité :

protected void NextButton_Click(object sender, EventArgs e)
{
if (Page.IsValid)
ActivityController.Execute(ActivityStateResult.Next);
}

protected void CancelButton_Click(object sender, EventArgs e)
{
ActivityController.Execute(ActivityStateResult.Cancel);
}

Nous voilà donc avec une implémentation pour une IHM web de la question qui contient uniquement de la connectique avec les autres couches. Il nous manque encore un branchement, est-ce que vous voyez lequel ?

Si oui, vous avez gagné... toute notre estime !

Nous aurons l'occasion d'y revenir mais l'essentiel est d'avoir pu pratiquer à travers ce prototype d'écran la mise en oeuvre du principe de séparation entre la logique métier et la présentation, approche qui nous permet avec le temps de satisfaire notre préoccupation de développer une application modulaire et évolutive.

Nous sommes maintenant prêts à nous jeter véritablement à l'eau et nous lancer dans l'équipée du développement d'une application métier avec Salamanca. En bon capitaine, nous rendrons bientôt compte des conditions de notre départ dans ce carnet de bord.

Préparation

Mediteranean map

Maintenant que nous avons fait connaissance avec l'équipement (Salamanca), l'équipage (votre dévoué capitaine) et l'équipée (mon projet), nous allons préparer notre itinéraire, histoire de ne pas partir pour l'inconnu.

Plutôt que fixer une destination, nous préfèrons vous embarquer pour une croisière (à vous de voir si elle s'amuse).

Elle aura pour escales :

Une fois cet itinéraire bouclé, nous prévoyons déjà de le réitérer afin d'améliorer notre connaissance du parcours grâce à l'expérience acquise et d'exploiter les évolutions futures de l'équipement.

Nous serons peut-être aussi amené à dériver vers d'autres rivages au gré des vents rencontrés entre chaque escale.

N'hésitez pas également à faire part d'autres voies à explorer.

Mais avant de partir avec ce plan de route, nous allons nous mettre en situation et tester notre "bateau" avec un essai en "eaux calmes" à travers :

Paquebot La Pallice

Et pour se mettre en condition, rien de tel qu'un air d'heureux présage.

Georges Brassens - Heureux qui comme Ulysse


free music

Embarquement prochain

La version 1.0 (alpha 1) de l'usine à logiciels Salamanca est sortie il y a maintenant 3 mois et en tant qu'adopteur de la première heure ("Early adopter"), je compte faire partager à travers ce journal de bord les moments de plénitude comme les mauvais grains que je vis grâce à l'utilisation de cet outil.

Si je fais l'analogie avec une expédition en bateau, c'est que je préfère partir avec une carte et un cap dans ma façon d'aborder mes projets de développement. Je me sens en effet plus comme un poisson dans l'eau dans le rôle d'analyste que dans le rôle de programmeur même si mon CV revendique plusieurs années d'expérience en développement web et mobile sous .NET.

C'est pourquoi je vais aborder la navigation dans le monde de Salamanca à travers l'un des projets sur lequel je travaille depuis maintenant 6 mois : eProject.

Ce service vise à accélérer la prise de décision lors du lancement d'un projet de développement métier. Il s'appuie sur un processus défini de production d'un prototype à partir d'une expression structurée du besoin. L'idée est de mettre entre les mains du porteur de projet une ébauche de solution pour faciliter le soutien et l'implication des différents intervenants.

La mise en oeuvre d'un processus répondant à une problématique métier (dans ce cas le lancement d'un projet) entre directement dans la ligne de produits définie pour l'usine à logiciels Salamanca : les applications métier.

J'attends ainsi de Salamanca qu'elle m'aide à :

  • développer, faire évoluer et maintenir sur la durée (plusieurs années) un service en ligne dédié aux entreprises
  • réaliser rapidement (en 1 ou 2 semaines) des prototypes d'application métier

C'est dans ce cadre que je souhaite partager publiquement mon expérience de l'utilisation de Salamanca.

Bienvenue à bord !