Vous êtes sur la page 1sur 17

REALISATION D'UN LOGICIEL DE COMPTABILITE

A. Introduction

L'objectif est de "tester" l'utilisation de la notation UML et d'un processus unifi pour la ralisation d'une
application de gestion.

L'application choisie est simple et possde toutes les caractristiques "classiques" du domaine : interface
utilisateur, entits persistantes, traitements (calculs et dition d'tats)

Cette application a dj t ralise "classiquement" l'aide d'access (version disponible sur le site du certa). Il
sera sans doute intressant de comparer les deux versions.

L'ide de base est de faire simple pour commencer : un seul utilisateur (le comptable) utilise une application
(compta) pour tenir la comptabilit de son entreprise. L'environnement technique est monoposte, mais
l'application devrait pouvoir tre dploye en deux ou trois niveaux (application distribuable).

Le processus utilis tente de s'inspirer fortement de 2TUP dcrit par Pascal ROQUES et Franck VALLEE dans
"UML en action" chez Eyrolles.

Les outils utiliss sont DELPHI 5 et INTERBASE 6. L'application a t ralise en trois itrations successives,
seule la premire sera entirement dcrite ici. L'application fournie correspond par contre au rsultat final.

B. Capture des besoins

1. Besoins fonctionnels

Les fonctionnalits attendues sont les suivantes :

- Saisie du plan de comptes


- Saisie des critures
- Edition du journal, du grand livre et de la balance tout moment
- Edition du compte de rsultat et du bilan tout moment
- Gestion des oprations de fin d'exercice (critures de regroupement, rouverture des comptes)

Diagramme de contexte

Pierre Loisel Logiciel de comptabilit Page 1/17


Diagramme des cas d'utilisation

Gestion du plan de comptes

Ce cas d'utilisation permet au comptable d'ajouter, de modifier ou de supprimer des comptes du plan de comptes
de l'entreprise.

Scnario : le comptable saisit le compte Banque (n 512). Le logiciel enregistre ce nouveau compte.

Saisie des critures

Il s'agit de saisir (modifier, supprimer) les critures comptables.

Scnario : le comptable enregistre une criture correspondant au rglement d'un client (2 000 F par chque).
L'criture porte le numro 124, est date du 15/12/2000, et a pour libell "Chque client n 12458956, bordereau
de remise n 78945". Cette opration comporte deux lignes : crdit de 2 000 F du compte 41101 (client Dubois),
dbit de 2 000 F du compte 512 (Banque).

Consultation

Le comptable peut consulter l'ensemble des informations saisies (plan de comptes et critures). De plus, il peut
tout moment :

- imprimer le journal comptable,


- consulter le grand-livre l'cran,
- imprimer une balance des comptes, un compte de rsultat ou un bilan provisoire.

Pierre Loisel Logiciel de comptabilit Page 2/17


Travaux de fin d'exercice

Les travaux de fin d'exercice comprennent les tches squentielles suivantes :


- Edition d'une balance avant rsultat.
- Edition du compte de rsultat.
- Passation des critures de regroupement (cette phase permet de "vider" les comptes de charges et de produits
et de renseigner le compte de rsultat ).
- Balance aprs calcul du rsultat : seuls les comptes de bilan (actif et passif) apparaissent.
- Edition du bilan.
- Rouverture des comptes.

2. Besoins techniques

L'application doit prendre appui sur un SGBDR pour la gestion des donnes. Il s'agit d'une application mono-
utilisateur, mais elle doit tre distribuable de manire supporter l'volution vers une architecture deux ou trois
niveaux.

PREMIERE ITERATION

Cette premire itration se contentera d'implmenter les deux premiers cas d'utilisation : "gestion du plan de
comptes" et "saisie des critures".

A. Analyse

1. Diagramme de classes (version 1)

Le type de compte permet de distinguer les comptes d'actif, de passif, de charge et de produit.

Pierre Loisel Logiciel de comptabilit Page 3/17


2. diagrammes de squence

Cas d'utilisation Gestion du plan de comptes

Le comptable fournit au systme le numro, l'intitul et le type du compte crer.

Cas d'utilisation Saisie des critures

Le comptable fournit le numro, la date et le libell de l'criture. Il indique galement le montant et le sens
(dbit, crdit) de chaque mouvement port sur un compte.

Le systme vrifie la cohrence de l'criture (somme des dbits = somme des crdits).

Pierre Loisel Logiciel de comptabilit Page 4/17


3. Diagramme de classes (version 2)

Les diagrammes de squences dtaillant les deux cas d'utilisation choisis pour la premire itration permettent
d'enrichir le diagramme de classes.

B. Conception gnrique

Cette phase permet de "trouver la solution technique" : quelle architecture utiliser pour l'application afin de
respecter les besoins techniques ?

L'intrt de cette question est surtout de pouvoir rutiliser le travail correspondant pour toute application future
ayant les mmes besoins techniques.

L'tude d'une solution technique d'implmentation est prsente dans le document joint "implementation.doc".

C. Conception

1. Etude du dploiement

La solution de dploiement est vite trouve : une application utilisateur sur le poste de travail du comptable. Le
SGDBR sera hberg sur un serveur d'applications ou sur le poste du comptable, ceci est totalement transparent.
Par contre, le caractre distribuable de l'application permet toutes les volutions.

2. Interface utilisateur

Outre un menu gnral, cette premire itration comporte deux crans :

- Menu gnral :

Le bouton "Plan de comptes" permet d'ouvrir la fiche "Saisie des comptes".

Pierre Loisel Logiciel de comptabilit Page 5/17


Le bouton "Ecritures" permet d'ouvrir la fiche "Saisie des critures".

- Saisie des comptes :

- Saisie des critures :

Pierre Loisel Logiciel de comptabilit Page 6/17


3. Diagramme de classes (version 1)

- Les classes prfixes par "TF" correspondent des interfaces utilisateur (Fiches). On retrouve donc
TF_Compte et TF_Ecriture.
- Les classes prfixes par "TC" reprsentent des objets contrleurs qui encapsulent la logique du traitement.
- Les classes prfixes par "TE" correspondent aux tables du SGDBR.

4. Diagrammes de squence

Saisie d'un compte

Ce diagramme rvle l'existence de la mthode "ajout" dans la classe TC_Compte.

Saisie d'une criture (Voir diagramme page suivante).

- Ce diagramme montre les choix oprs en ce qui concerne la rpartition des rles.
- Les classes interface n'ont qu'un seul objet (bien que l'on puisse concevoir que l'utilisateur ouvre deux fois la
fiche, et cr ainsi deux objets).
- Les classes contrleur peuvent avoir plusieurs objets car elles peuvent tre utilises par plusieurs classes
interface diffrentes.
- Le diagramme met en vidence le fait que le contrleur d'criture doit mmoriser le numro de l'criture en
cours. Ce contrleur conserve d'ailleurs en permanence un accs l'criture courante. Cette solution permet
de traiter de la mme manire la modification d'une criture (effectue aprs une recherche par exemple).
- D'une manire gnrale, tout objet "contrleur d'entit" (cas particulier d'un objet contrle) doit possder un
accs la table correspondante (composant dataset intgr l'outil de dveloppement).

Pierre Loisel Logiciel de comptabilit Page 7/17


Pierre Loisel Logiciel de comptabilit Page 8/17
5. Diagramme de classes (version 2)

Ces deux diagrammes de squence permettent de complter le diagramme de classes :

Remarques :

- la mthode "montant" de la classe Mouvement (analyse) a disparu.


- Chaque classe contrleur possde un accs la table correspondante, cet accs est simplement matrialis
par l'association.

6. Diagramme de classes (version 3)

L'tude des autres scnarios des cas d'utilisation permettrait de dgager d'autres mthodes pour les classes
contrleur : modifier(), supprimer()

Cependant, ces mthodes (ainsi que l'ajout) seront ralises de manire totalement transparente par un objet
navigateur intgr l'outil de dveloppement. Leur prsence sur le diagramme n'a donc pas grand intrt. Aprs
cette simplification, on obtient le diagramme de classes prsent page suivante.

Pierre Loisel Logiciel de comptabilit Page 9/17


Remarques :

- Dans la classe TC_Ecriture, "valide" est une mthode et non une donne, mme si mon AGL ne permet pas
de faire la diffrence ici.
- Le lien entre TF_Ecriture et les deux classes contrleur sera ralis par un ensemble de contrles orients
donnes (dans TF_Ecriture) connect une source de donnes (dataset) dans chacune des classes contrleur.
- Le lien entre les classes contrleur et les classes "TE_" (qui correspondent des tables relationnelles) sera
assur par la prsence d'une source de donnes (dataset) dans les classes contrleur, cette source "pointant"
sur la table correspondante.

Pierre Loisel Logiciel de comptabilit Page 10/17


D. Ralisation

1. Base de donnes relationnelle

COMPTE (numro, intitul, type)


ECRITURE (numro, date, libell)
MOUVEMENT (criture#, compte#, dbit, crdit)

Cette base de donnes reprsente l'implmentation des classes E_Compte, E_Ecriture et E_Mouvement.

Cette base peut tre cre l'aide du script ci-dessous :

drop database;

set sql dialect 1;

create database "e:\documents\uml\compta\comptabilite.gdb" user "SYSDBA" password "masterkey";

create table compte (


numCpte varchar(10) not null,
intituleCpte varchar(50),
typeCpte smallint,
primary key(numCpte)
);

create table ecriture(


numEcr integer not null,
dateEcr date,
libelleEcr varchar(50),
primary key(numEcr)
);

create table mouvement(


numEcr integer not null,
numCpte varchar(10) not null,
debit decimal(10,2) not null,
credit decimal(10,2) not null,
primary key(numEcr,numCpte),
foreign key(numEcr) references ecriture(numEcr),
foreign key(numCpte) references compte(numCpte)
);

create generator genEcrId;


set generator genEcrId to 0;

set term ^;
create procedure idNouvelleEcr
returns (idNew integer)
as
begin
idNew=gen_id(genEcrId,1);
end^
set term ;^

set term ^;

Pierre Loisel Logiciel de comptabilit Page 11/17


create procedure sommeDebitEcr(ecr integer)
returns (val decimal(10,2))
as
begin
select sum(debit)
from mouvement
where numEcr=:ecr
into :val;
end^
set term ;^

set term ^;
create procedure sommeCreditEcr(ecr integer)
returns (val decimal(10,2))
as
begin
select sum(credit)
from mouvement
where numEcr=:ecr
into :val;
end^
set term ;^

Remarques :

- Les mthodes sommeDebitEcr et sommeCreditEcr sont ralises l'aide de procdures stockes.


- Le gnrateur genEcrId et la procdure stocke idNouvelleEcr sont destins grer une numrotation
automatique des critures.

Il reste ensuite ajouter un lment "applicatif" (TA_compta) et paramtrer son composant DataBase.

2. Classes contrleurs

Chacune de ces classes hrite de la classe abstraite TC_controleur dfinie dans la solution technique.

Classe TC_compte

La dfinition de la classe TC_compte est immdiate l'aide de la solution d'implmentation retenue. Il suffit de
crer un nouvel lment de type "contrleur" et de paramtrer le composant Table.

Classe TC_ecriture

Mis part ce qui est hrit de TC_controleur, cette classe dfinit une fonction boolenne "valide" conformment
ce qui a t prvu prcdemment. Voici le code de cette mthode :

function TC_ecriture.valide:boolean;
var controlMouvement:TC_mouvement;
ecr:integer;
res:boolean;
begin
ecr:=donnees.FieldValues['numEcr'];
controlMouvement:=TC_mouvement.Create(Self);
res:=(controlMouvement.sommeDebitEcr(ecr)=controlMouvement.sommeCreditEcr(ecr));
controlMouvement.Free;
valide:=res;
end;

Il faut ensuite raliser la numrotation automatique des critures. La solution retenue est la suivante : lors de
l'ajout d'un n-uplet dans la table, un vnement est gnr au niveau du composant Ttable associ. On traite cet

Pierre Loisel Logiciel de comptabilit Page 12/17


vnement en demandant un nouveau numro au SGBD via la procdure stocke idNouvelleEcr. Il reste ensuite
affecter le champ correspondant dans le composant Ttable.

Remarque : une autre solution consiste crer un trigger au niveau du SGBD, ce trigger gnrant le numro. Le
problme qui se pose est qu'il est difficile de rcuprer ce numro dans l'application (ce n'est notamment pas
obligatoirement le dernier cr dans un contexte multi-utilisateurs).

Pour implmenter cette solution il faut crer dans la classe TC_ecriture :

- Un composant "procdure stocke" (ps_idNouvelleEcr) qui permettra d'utiliser la procdure de mme nom
ralise par le SGBD.
- Une procdure traitant l'vnement AfterInsert du composant Ttable :

procedure TC_ecriture.tbAfterInsert(DataSet: TDataSet);


begin
inherited;
ps_idNouvelleEcr.ExecProc;
tb.FieldValues['numEcr']:=ps_idNouvelleEcr.ParamByName('idNew').AsInteger;
end;

Classe TC_mouvement

a. Ralisation des mthodes sommeDebitEcr et sommeCreditEcr :

- Deux composants "procdures stockes" ps_sommeDebitEcr et ps_sommeCreditEcr permettant l'appel des


procdures de mme nom dans le SGBD.
- Deux mthodes dans la classe TC_mouvement prsentes ci-dessous.

function TC_mouvement.sommeDebitEcr(ecr:integer):Currency;
begin
ps_sommeDebitEcr.ParamByName('ECR').AsInteger:=ecr;
ps_sommeDebitEcr.ExecProc;
sommeDebitEcr:=ps_sommeDebitEcr.paramByName('VAL').AsCurrency;
end;

function TC_mouvement.sommeCreditEcr(ecr:integer):Currency;
begin
ps_sommeCreditEcr.ParamByName('ECR').AsInteger:=ecr;
ps_sommeCreditEcr.ExecProc;
sommeCreditEcr:=ps_sommeCreditEcr.paramByName('VAL').AsCurrency;
end;

b. Rfrence aux autres contrleurs

L'cran de saisie prvu pour les critures montre qu'il faut un champ rfrence permettant d'associer l'intitul du
compte un mouvement. Il faut donc prvoir dans la classe TC_mouvement :

- Une proprit refCompte de type TC_compte (contrleur de compte).


- La cration de ce contrleur lors de la cration d'un objet TC_mouvement (ainsi que l'affectation du champ
rfrence).
- La destruction de ce contrleur lors de la destruction d'un objet TC_mouvement.

Un contrleur de mouvement doit pouvoir tre synchronis avec un contrleur de compte (pour pointer les
mouvements du compte en cours), et avec un contrleur d'criture (pour pointer les mouvement de l'criture en
cours). On doit donc dfinir une mthode synchroCompte et une mthode synchroEcriture.

Pierre Loisel Logiciel de comptabilit Page 13/17


D'aprs ce qui vient d'tre vu, on trouve les lments suivants :

type
TC_mouvement = class(TC_controleur)
tbIntituleCompte: TStringField;
procedure DataModuleCreate(Sender: TObject);
procedure DataModuleDestroy(Sender: TObject);
private
refCompte:TC_compte;
public
procedure synchroEcriture(var ds_ecriture:TDataSource);
procedure synchroCompte(var ds_compte:TDataSource);
function sommeDebitEcr(ecr:integer):Currency;
function sommeCreditEcr(ecr:integer):Currency;
end;

var
C_mouvement: TC_mouvement;

implementation

{$R *.DFM}

procedure TC_mouvement.DataModuleCreate(Sender: TObject);


begin
inherited;
refCompte:=TC_compte.Create(Self);
tbIntituleCompte.LookupDataSet:=refCompte.donnees;
tb.Open;
end;

procedure TC_mouvement.DataModuleDestroy(Sender: TObject);


begin
inherited;
refCompte.Free;
end;

procedure TC_mouvement.synchroEcriture(var ds_ecriture:TDataSource);


begin
synchroniser(ds_ecriture,'numEcr','numEcr');
end;

procedure TC_mouvement.synchroCompte(var ds_compte:TDataSource);


begin
synchroniser(ds_compte,'numCpte','numCpte');
end;

Pierre Loisel Logiciel de comptabilit Page 14/17


3. Classes Fiches

Leur ralisation ne pose aucun problme particulier, il suffit d'ajouter deux lments "fiche" du panneau
"modles UML".

type
TF_compte = class(TForm)
ds: TDataSource;

procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure FormShow(Sender: TObject);
private
public
controlCompte:TC_compte;
end;

procedure TF_compte.FormCreate(Sender: TObject);


begin
controlCompte:=TC_compte.Create(Self);
end;

procedure TF_compte.FormDestroy(Sender: TObject);


begin
controlCompte.Free;
end;

procedure TF_compte.FormShow(Sender: TObject);


begin
ds.DataSet:=controlCompte.donnees;
end;

type
TF_ecriture = class(TForm)

bc_verifier: TButton;
ds_ecriture: TDataSource;
ds_mouvement: TDataSource;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure bc_verifierClick(Sender: TObject);
procedure FormShow(Sender: TObject);
private
public
controlEcriture:TC_ecriture;
controlMouvement:TC_mouvement;
end;

procedure TF_ecriture.FormCreate(Sender: TObject);


begin
controlEcriture:=TC_ecriture.Create(Self);
controlMouvement:=TC_mouvement.Create(Self);
end;

procedure TF_ecriture.FormDestroy(Sender: TObject);


begin
controlEcriture.Free;
controlMouvement.Free;
end;

Pierre Loisel Logiciel de comptabilit Page 15/17


procedure TF_ecriture.bc_verifierClick(Sender: TObject);
begin
A_compta.verifierEcriture;
end;

procedure TF_ecriture.FormShow(Sender: TObject);


begin
ds_ecriture.DataSet:=controlEcriture.donnees;
ds_mouvement.DataSet:=controlMouvement.donnees;
end;

Remarque : le bouton vrifier renvoie une mthode de la classe "applicatif" TA_compta.

4. Le menu gnral

Chacun de ses boutons de commande renvoie une mthode de la classe "applicatif" TA_compta :

type
TF_menu = class(TForm)
bc_planComptes: TButton;
bc_ecritures: TButton;
bc_quitter: TButton;
procedure bc_planComptesClick(Sender: TObject);
procedure bc_ecrituresClick(Sender: TObject);
procedure bc_quitterClick(Sender: TObject);
private
public
end;

procedure TF_menu.bc_planComptesClick(Sender: TObject);


begin
A_compta.planComptes;
end;

procedure TF_menu.bc_ecrituresClick(Sender: TObject);


begin
A_compta.saisieEcritures;
end;

procedure TF_menu.bc_quitterClick(Sender: TObject);


begin
Close;
end;

Pierre Loisel Logiciel de comptabilit Page 16/17


5. La classe "contrle applicatif" TA_compta

Chacune de ses mthodes s'appuie sur les classes contrleurs et les classes fiches du projet. Cette classe s'obtient
partir du modle UML "applicatif".

type
TA_compta = class(TDataModule)
db: TDatabase;
private
public
procedure planComptes;
procedure saisieEcritures;
procedure verifierEcriture;
end;

procedure TA_compta.planComptes;
begin
F_compte.Show;
end;

procedure TA_compta.saisieEcritures;
begin
F_ecriture.controlEcriture.rafraichir;
F_ecriture.controlMouvement.synchroEcriture(F_ecriture.ds_ecriture);
F_ecriture.controlMouvement.trier('credit');
F_ecriture.Show;
end;

procedure TA_compta.verifierEcriture;
begin
if F_ecriture.controlEcriture.valide then
ShowMessage('Ecriture correcte')
else
ShowMessage('Ecriture incorrecte');
end;

DEUXIEME ET TROISIEME ITERATIONS

La deuxime itration a permis d'ajouter la ralisation du cas d'utilisation "consultation". Les classes suivantes
ont donc t cres :

Classe Rle
TR_journal Etat servant l'impression du journal
TF_grandLivre Fiche permettant d'afficher le grand livre
TR_balance Etat d'impression de la balance
TR_bilan Idem pour le bilan
TR_compteResultat Idem pour le compte de rsultat

Remarque : le rsultat comptable est calcul l'aide d'une procdure stocke.

La troisime itration est la dernire, il s'agit d'ajouter la ralisation du cas d'utilisation "travaux de fin
d'exercice".

Aucun classe n'est ajoute, la classe TF_menu est enrichie de nouveaux boutons de commande, l'ensemble des
fonctionnalits correspondantes tant implmentes dans la classe applicatif TA_compta.

Le projet compta.dpr correspond l'application termine.

Pierre Loisel Logiciel de comptabilit Page 17/17