Rapport genie logiciel

Rapport du TP1 Genie Logiciel Avanc´e
SONFACK S. Serge et ZONGO Sylvain
February 2018
UIVERSITE INSTITUT DE LA
NATIONALE FRANCOPHONIE
DE VIETNAM POUR L’INNOVATION
1

IFI-VNU Projet Genie Logiciel TP1
Table des matières
1 Analyse et Conception 3
1.1 Méthode agile extreme programming . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Analyse des spécifications de l’application . . . . . . . . . . . . . . . . . . . 3
1.3 Planning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4.1 Itérration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4.2 Première Itérration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4.3 Deuxième Itérration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.4 Troisième Itérration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4.5 Sxième Itérration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.4.6 Diagramme de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2 Outils de développement 26
3 Code source 27
Table des figures
1 planification du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Diagramme de cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3 Diagramme de séquence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
4 Diagramme de cas d’utilisation : consulter compte . . . . . . . . . . . . . . . . . . 9
5 Diagramme de sequence : consulter compte . . . . . . . . . . . . . . . . . . . . . . 10
6 Diagramme de cas d’utilisation : faire recherche . . . . . . . . . . . . . . . . . . . 12
7 Diagramme de sequence : faire recherche . . . . . . . . . . . . . . . . . . . . . . . 14
8 Diagramme de cas d’utilisation : faire transaction . . . . . . . . . . . . . . . . . . 16
9 Diagramme de sequence : faire transaction . . . . . . . . . . . . . . . . . . . . . . 18
10 Diagramme de cas d’utilisation: calcul interet . . . . . . . . . . . . . . . . . . . . 20
11 Diagramme de sequence : calcul interet . . . . . . . . . . . . . . . . . . . . . . . . 21
12 Diagramme de cas d’utilisation:produire rapport . . . . . . . . . . . . . . . . . . 23
13 Diagramme de sequence :produire rapport . . . . . . . . . . . . . . . . . . . . . . 24
14 Diagramme de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2

Introduction
Le génie logiciel (software engineering) représente l’application de principes d’ingénierie au
domaine de la création de logiciels. Il consiste à identifier et à utiliser des méthodes, des pratiques
et des outils permettant de maximiser les chances de réussite d’un projet logiciel. Ce TP (travail
Pratique) a donc pour objectif de nous permettre de rationaliser et d’optimiser le processus de
production d’un logiciel en intégrant le concept de la programmation orientée objet. Nous allons
d’abord présenter les spécifications de l’application, ensuite nous allons appliquer la méthode
Agile extreme programming pour l’implémentation et la gestion de notre projet.
1 Analyse et Conception
1.1 Méthode agile extreme programming
XP(extreme programming) est une méthode agile adaptée pour une équipe réduite et qui
permet de pousser à l’extrème les principes simples. Cette méthode des gestions repose sur des
valeurs telles que : le courage, le simplicité, le respect et surtout la communication entre les
différents membres de l’équipe.
XP dans la pratique repose sur un cycle de dévelopement qui commence par un planning qui
orgarnise le travail en tâche dans un ordre de priorité. Par la suite chaque tâche retiré dans la liste
de priorité est exécutée et représente une itération. Chaque itération passe par une conception,
une implementation, un test et finie par un checking sur les modification à apporter sur la ou les
itération précedente.
Tel sera notre méthodologie de travail.
1.2 Analyse des spécifications de l’application
L’application réalisée a de diverses fonctionnalités. L’application permet la mise en œuvre d’un
système de gestion de comptes des clients dans une banque. Elle permet l’ouverture d’un ou de
plusieurs compte(s) pour tout client avec des taux d’intérêt différents. Elle permet de faire une
transaction(faire un dépôt ou un retrait) sur un compte créé. L’application permettra également
de consulter un compte, de calculer le taux d’intérêt pour tous les comptes et de mettre le solde
de chaque compte à jour. L’application permet de faire aussi des rapports qui incluent la liste
des comptes. L’application permet aussi de faire des recherches sur les comptes et de reconnaˆıtre
si un client possède un ou plusieurs comptes dans une banque.
– créer un nouveau compte,
– déposer un certain montant d’argent dans un compte,
– retirer un certain montant d’argent d’un compte,
– consulter le solde d’un compte,
– calculer l’intérêt pour tous les comptes et mettre à jours leur solde,
– produire un rapport qui inclut une liste de comptes avec les informations suivantes : le
numéro de compte, le solde, et les transactions effectuées (déposer et retirer l’argent) depuis
que le compte est créé.
– faire une recherche qui permet, à partir du numéro d’identification d’une personne, de
savoir si elle possède un ou des comptes dans la banque.
1.3 Planning
Dans cette partie tout le projet est planifié et priorisé en se basant sur les spécifications
3

Fig. 1 – planification du projet
1.4 Conception
1.4.1 Itérration
1.4.2 Première Itérration
– Cas d’utilisation : creer compte
Fig. 2 – Diagramme de cas d’utilisation
– description
4

Créer compte ID : CC-1
Acteur primaire Gestionnaire
Acteur secondaire Client
Description Permet au gestionnaire de créer les comptes client
Auteurs SONFACK et ZONGO
Version 1.0
Système Système de gestion de banque
Intervenant gestionnaire
Précondition Lancer l’application
Opérations normale
1 Lancer ou exécuter l’application
2 Sélectionner l’option créer compte
3 Affichage du formulaire de création de compte
4 Remplir le formulaire de création de compte
5 Enregistrer le formulaire
Post condition
1 Retour à l’état initial
Exception
4.a Informations invalides
4.a.1 ré-afficher le formulaire
4.a.2 Renseigner les champs erronés
4.a.3 Passer au l’action 4
5.a Si le client existe
5.a.1 Demander voulez vous ajouter un nouveau compte?
5.a.2 Si oui
5.a.3 Demander l’identité du client
5.a.4 Retour à l’action 4
5

– diagramme de séquence : creer compte
Fig. 3 – Diagramme de séquence
– code L’identifiant du compte est générer automatiquement
public class Compte{
public static int indiceCompte = 0;
% liste des transactions du compte
ArrayList<Transaction> listeTransaction = new ArrayList<Transaction>();
private Client client;
private int numCompte;
private double solde ;
public int tauxInteret;
public Compte(Client client, int taux ) {
Compte.indiceCompte = Compte.indiceCompte + 1;
this.numCompte = Compte.indiceCompte ;
this.solde = 0;
this.tauxInteret = taux;
client.listeCompte.add(this);
System.out.println("tCompte = "+this.numCompte+" ; nom client =
"+client.nomClient+" identifiant =
"+client.getIdClient(client)+" ; montant =
"+this.getSolde() +" et taux = "+this.tauxInteret+"%" );
}
– test
6

class ClientTest {
@Test
void test() {
Banque BIDV = new Banque();
assertNotNull("Non null", BIDV);
/*
Deux clients diffrentes de la meme banque sont diffrentes */
Client client1 = new Client(BIDV, "serge");
Client client2 = new Client(BIDV,"landry");
assertNotNull("Not null test",client1);
assertNotNull("Not null test",client2);
assertNotEquals(client1.nomClient, client2.nomClient);
assertNotEquals(client1.getIdClient(), client2.getIdClient());
assertNotEquals(client1.nomClient, client2.nomClient);
assertNotEquals(client1.getIdClient(), client2.getIdClient());
System.out.println("Fin test");
}
@FixMethodOrder()
class CompteTest {
@Test
void test0() {
Compte cpt1 = new Compte(client1, 3);
7

assertNotNull("Not null", cpt1);
assertNotNull("Not null", cpt2);
assertEquals(cpt1.getTaux(), 3);
assertEquals(cpt2.getTaux(), 4);
System.out.println("Fin test0");
}
– checking
Toujours cr´eer un client avant de cr´eer son compte Tout compte sans transaction doit avoir
un solde nul
8

1.4.3 Deuxième Itérration
– Ajout du cas d’utilisation : consulter compte
Fig. 4 – Diagramme de cas d’utilisation : consulter compte
– description
Consulter compte ID: CC-2
Description Permet au gestionnaire de consulter les comptes des clients
Version 1.0
Intervenant Gestionnaire
1 Lancer ou exécuter l’application
2 Demande de consultation de compte
3 affichage de la zone de saisie de l’identifant du compte
4 Saisir le nom ou l’identifiant du client
5 Choisir le type de recherche
6 Si recherche par identifiant
7 Affichage du contenu correspondant
8 Sinon si recherche par nom
9 Affichage des noms identiques
10 Sélection de l’identifiant correspondant
11 Affichage du contenu compte
Post condition
9

– diagramme de s´equence : consulter compte
Fig. 5 – Diagramme de sequence : consulter compte
– code
public class Client {
public static int indiceClient=0 ;
public String nomClient ;
private int idClient;
public ArrayList<Compte> listeCompte = new ArrayList<Compte>();
public Compte getCompte(int numCompte) {
Compte compte = null ;
for(int i = 0 ; i < this.listeCompte.size(); i++) {
if(this.listeCompte.get(i).getNumCompte() == numCompte) {
compte = this.listeCompte.get(i);
}
10

}
return compte;
}
– test
void test1() {
cpt1.setInteret();
assertEquals(cpt1.getSolde(), 0.0,0);
// type transaction
TypeTransaction typeTrs1 = new TypeTransaction(BIDV,"depot");
TypeTransaction typeTrs2 = new TypeTransaction(BIDV,"retrait");
// transaction
Transaction Trs1 = new Transaction(client1, cpt1, typeTrs1, 500);
//consultation
assertEquals(cpt1.getSolde(), 300,0);
cpt1.setInteret();
double intCal = (300.0*2.0)/100.0 + 300.0;
assertEquals(cpt1.getSolde(), intCal,0);
}
– checking
Consulter une compte à partir d’un numéro donné et retourner les informations du compte
( solde et interet)
11

1.4.4 Troisi`eme It´erration
– Ajout de cas d’utilisation : faire recherche
Fig. 6 – Diagramme de cas d’utilisation : faire recherche
– description
12

Faire recherche ID : FR-1
Description Permet au gestionnaire de faire une recherche
Version 1.0
Précondition Lancer ou exécuter l’application
1 Saisir le mot à rechercher
2 Afficher le résultat de la recherche
Post condition
Exception
3.a. Renseigner les champs erronés
3.a.3 Passer à l’action 4
– diagramme de séquence : faire recherche
– code
public class Banque {
// liste des clients de la banque
private HashSet<Client> listeClient = new HashSet();
// liste des types de transaction de la banque
private HashSet<TypeTransaction> listeTypeTransaction = new HashSet();
public HashSet<Client> getClient(){
return this.listeClient;
}
// recherche un client connaissant a partir de son identifiant
public Client getClient(int idClient) {
Client client = null ;
for(Client clt:this.listeClient) {
if(clt.getIdClient() == idClient) {
client = clt;
}
}
return client;
}
– test
/**
* Test recherche
*/
13

Fig. 7 – Diagramme de sequence : faire recherche
void test2() {
assertNotEquals(BIDV.getTypeTransaction(), null);
assertEquals(BIDV.getClient(), null);
Client client1 = new Client(BIDV, "serge1");
Client client2 = new Client(BIDV,"landry1");
14

assertEquals(BIDV.getClient(1).nomClient, "serge1");
assertEquals(BIDV.getClient(10), null );
}
– checking
Recherche le client `a partir de la classe Banque Retourner l’objet client
15

Cinquième ItérrationAjout de cas d’utilisation : faire transaction Le diagramme de cas
d’utilisation Le diagramme de cas d’utilisation représente la structure des grandes fonc-
tionnalités nécessaires aux utilisateurs du système. C’est diagramme statique du modèle
UML, celui où s’assure la relation entre l’utilisateur et les objets que le système met en
œuvre.
Fig. 8 – Diagramme de cas d’utilisation : faire transaction
–
– description
16

Faire transaction ID: FT-1
Description Permet au gestionnaire d’effectuer une transaction
Version 1.0
Pré condition Lancer ou exécuter l’application
1 Demande d’effectuer une transaction
2 Saisir l’identifiant client
3 Choisir l’opération à effectuer
4 Si choix est dépôt
5 Enregistrer montant
6 Faire mise à jour du compte
7 Si choix est retrait
8 Vérifier si montant à retirer ¡montant du compte
9 Si oui effectuer l’opération
10 Mise à jour du compte
Post condition
Exception
3.a.2 Renseigner les champs erronés
3.a. Passer au l’action 4
– diagramme de séquence : faire transaction
– code
class TransactionTest {
@Test
void test() {
// type transaction
17

Fig. 9 – Diagramme de sequence : faire transaction
TypeTransaction typeTrs1 = new TypeTransaction(BIDV,"depot");
TypeTransaction typeTrs2 = new TypeTransaction(BIDV,"retrait");
// transaction
Transaction Trs2 = new Transaction(client1, cpt1, typeTrs1,
-100);
18

assertEquals(cpt1.getSolde(), 300);
}
}
– test
– checking
Une transaction doit être definie avec son type et son montant, la date à la quelle elle a
étét effectuée. Il ne doit pas y avoir des transaction negatives
19

Cinquième ItérrationAjout de cas d’utilisation : calcul interet Le diagramme de cas d’utili-
sation Le diagramme de cas d’utilisation représente la structure des grandes fonctionnalités
nécessaires aux utilisateurs du système. C’est diagramme statique du modèle UML, celui
où s’assure la relation entre l’utilisateur et les objets que le système met en œuvre.
Fig. 10 – Diagramme de cas d’utilisation: calcul interet
–– description
– diagramme de séquence : calcul interet
– code
– test
20

Fig. 11 – Diagramme de sequence : calcul interet
}
/*
* Calcul d’interet
*/
public void calculateInteret() {
System.out.println("Client : "+clt.nomClient);
for(int i = 0 ; i < clt.listeCompte.size() ; i++) {
System.out.println("Numero de complte"+
clt.listeCompte.get(i).getNumCompte());
System.out.println("----Solde :
21

"+clt.listeCompte.get(i).getSolde()+"----");
clt.listeCompte.get(i).setSolde((clt.listeCompte.get(i).getTaux()*
clt.listeCompte.get(i).getSolde())/100 +
clt.listeCompte.get(i).getSolde());
System.out.println("----Nouveau solde :
"+clt.listeCompte.get(i).
getSolde()+" pour Interet :
"+clt.listeCompte.get(i).getTaux()+" ----");
}
System.out.println("------------------------");
}
}
– checking
Calcul les interets des clients de la banque tout en mettant ajour leurs solde
1.4.5 Sxième Itérration
– Ajout de cas d’utilisation : Produire rapport
– description
Produire rapport ID: CC-3
Acteur secondaire Gestionnaire
Description Permet au gestionnaire de produire des rapports des clients
Version 1.0
Intervenant Gestionnaire
1 Demande de production de rapport
2 Affichage du rapport incluant la liste des comptes
Postcondition
– diagramme de séquence : produire rapport
– code
22

Fig. 12 – Diagramme de cas d’utilisation:produire rapport
}
/**
23

Fig. 13 – Diagramme de sequence :produire rapport
* Cette fonction retourn le rapport des transation de la banque
*/
public void printRapport() {
System.out.println("##############################################");
System.out.println("### Rapport des transaction de la banque ####");
System.out.println("Nom : "+clt.nomClient);
for(int index =0 ; index< clt.listeCompte.size(); index++) {
System.out.println("Compte NO: "+
clt.listeCompte.get(index).getNumCompte());
24

System.out.println("Sole :
"+clt.listeCompte.get(index).getSolde()+"Euros");
for(int intTrs = 0 ;
intTrs <
clt.listeCompte.get(index).getListeTransaction().size();
intTrs++) {
if(
clt.listeCompte.get(index).getListeTransaction().
get(intTrs).getNomTypeTransaction().equals("depot")) {
System.out.println("---- Dposer un montant de "+
clt.listeCompte.get(index).getListeTransaction().get(intTrs).
getMontantTransaction()+"Euros pour le compte "+
clt.listeCompte.
get(index).getNumCompte()+"au "+clt.listeCompte.get(index).
getListeTransaction().get(intTrs).getDateTransaction());
}else if(clt.listeCompte.get(index).getListeTransaction().
get(intTrs).getNomTypeTransaction().equals("retrait")) {
System.out.println("---- Retirer un montant de "+
getMontantTransaction()+"Euros pour le compte "+
clt.listeCompte.get(index).getNumCompte()+"au "+
clt.listeCompte.get(index).
}
}
}
System.out.println("n-------------------n");
}
}
– test
– checking
Produire le rapport de tous les transactions effectuées dans la banque
1.4.6 Diagramme de classe
Le diagramme de classes montre la structure interne d’un système. Il permet de fournir une
représentation abstraite des objets du système qui vont interagir ensemble pour réaliser les cas
d’utilisation. Le diagramme de classes permet de modéliser les classes du système et leurs relations
indépendamment d’un langage de programmation particulier.
25

Fig. 14 – Diagramme de classe
Conclusion
Ce projet nous a permis d’apprendre les bsaes de la modelisation Unify modeling Languange
(UML) qui est un language de modélisation. Il nous a egalement permis de comprendre les
concepts de la programmation orientée objet et de léappliquer avec le langage Java. Il nous aussi
pousser à maˆıtriser l’utilisation de certains outils pour mener à bien le projet.
2 Outils de développement
– GanttProject
C’est un logiciel libre de gestion de projet, il permet la planification d’un projet à travers la
réalisation d’un diagramme de Gantt. Ecrit en Java,il peut etre utiliser sur de nombreux OS tel
que Windows, Linux, MacOS. Ce projet a été lancé par un étudiant de l’université de Marne La
Vallée en janvier 2003 et est maintenant proposé sous licence libre (GNU GPL)
– Sharelatex
C’est un éditeur LaTeX en ligne, collaboratif, en temps réel et compileur PDF. En comparaison
avec les autres éditeurs LaTeX, ShareLaTeX est une application basée sur un serveur web, qui
est donc accessible via un navigateur internet. Une version publique, et maintenue, est disponible
sur https://www.sharelatex.com
– EDI Eclipse
26

L’environnement de Développement Intégré Eclipse est sous projet, du projet Eclipse qui est
décliné et organisé en un ensemble de sous-projets de développements logiciels, de la fondation
Eclipse visant à développer un environnement de production de logiciels libre qui soit extensible,
universel et polyvalent, en s’appuyant principalement sur Java
– JRE : version 1.8
– StarUML
est un logiciel de modélisation UML, cédé comme open source par son éditeur, à la fin de son
exploitation commerciale, sous une licence modifiée de GNU GPL
– FramaPad
est un service en ligne de traitement de texte (une sorte de Word très simplifié), et de colla-
boratif (proche de Google Drive), mais reposant sur l’application libre EtherPad, reconnu dans
l’éducation comme outil permettant la production à plusieurs
– Github
C’est un service web d’hébergement et de gestion de développement de logiciels, utilisant le
logiciel de gestion de versions Git
– Git
C’est un logiciel de gestion de versions décentralisé. C’est un logiciel libre créé par Linus Torvalds,
auteur du noyau Linux, et distribué selon les termes de la licence publique générale GNU version
2
3 Code source
/**
*
*/
package com.ckomsa.controller;
import java.util.ArrayList;
import com.ckomsa.main.Banque;
/**
* Classe permettant de grer les clients
* @author sonfack
*
*/
public class Client {
public static int indiceClient=0 ;
public String nomClient ;
private int idClient;
public ArrayList<Compte> listeCompte = new ArrayList<Compte>();
/**
27

* Constructeur de la classe Client n’ayant pas de compte dans la systme
* @param banque est l objet de la classe Banque
* @param nom est le nom du client a crer
* @param id represente l’identifiant du client
* le constructeur ajoute directement le client dans la liste de client
*/
public Client(Banque banque, String nom , int id) {
// TODO Auto-generated constructor stub
this.nomClient = nom.toUpperCase();
this.idClient = id ;
banque.setListeClient(this);
}
/**
* Constructeur de la classe Client n’ayant pas de compte dans la systme
* @param banque est l objet de la classe Banque
* @param nom est le nom du client a crer
* Le constructeur ajoute directement le client dans la liste de client
* Le constructeur cre automatique l’identifiant du client crer
*/
public Client(Banque banque, String nom) {
Client.indiceClient = Client.indiceClient +1;
this.nomClient = nom.toUpperCase();
this.idClient = Client.indiceClient ;
banque.setListeClient(this);
System.out.print("n---- Creer un nouveau compte pour "+this.nomClient+"
avec :n");
}
/**
* Cette methode permet de retourner l’identifiant d’un client
* @param client un objet de la classe Client
* @return idClient l’identifiant de l’objet pass
*/
public int getIdClient(Client client) {
return client.idClient;
}
/**
* Cette methode permet de retourner l’identifiant d’un client
* cette fonction est sans paramettre
* @return idClient l’identifiant de l’objet pass
*/
public int getIdClient() {
return this.idClient;
}
/**
28

* Cette fonction permet d’imprimer les comptes de tous les clients
*/
public void printCompteClient() {
int compte ;
if(this.listeCompte.size() >0) {
System.out.println("---- Le client : "+this.nomClient+" pour Id :
"+this.getIdClient()+" dispose de :"+this.listeCompte.size()
+" ----" );
for(int i = 0 ; i < this.listeCompte.size() ; i++) {
compte = i+1;
System.out.println("* compte "+compte+" pour numero de
compte: "+this.listeCompte.get(i).getNumCompte());
}
}else {
System.out.println("---- Aucun compte pour "+this.nomClient+ "
pour Id : "+this.getIdClient()+" ----");
}
}
/**
* Cette fonction returne un compte etant donn un numero de compte
* @param numCompte le numero dont on recherche le compte
* @return null si aucun compte n a le numero ou le compte
*/
public Compte getCompte(int numCompte) {
Compte compte = null ;
for(int i = 0 ; i < this.listeCompte.size(); i++) {
if(this.listeCompte.get(i).getNumCompte() == numCompte) {
compte = this.listeCompte.get(i);
}
}
return compte;
}
}
//////////////////////// compte ////////////////////////////
/**
*
*/
import java.util.List;
/**
* @author sonfack
*
*/
29

public class Compte{
public static int indiceCompte = 0;
// liste des transactions du compte
ArrayList<Transaction> listeTransaction = new ArrayList<Transaction>();
//private Client client;
private int numCompte;
private double solde ;
public int tauxInteret;
/*
* Constructeur de la classe Compte qui permet de crer un compte sans transaction
*/
public Compte(Client client, int taux ) {
this.solde = 0;
this.tauxInteret = taux;
"+client.nomClient+" identifiant = "+client.getIdClient(client)+" ;
montant = "+this.getSolde() +" et taux = "+this.tauxInteret+"%" );
}
public Compte(Client client) {
this.solde = 0;
this.tauxInteret = 0;
"+client.nomClient+" identifiant = "+client.getIdClient(client)+" ;
montant = "+this.getSolde() +" et taux = "+this.tauxInteret+"%" );
}
public void printTransaction(Transaction transaction) {
if(transaction != null) {
if(transaction.getNomTypeTransaction().equals("depot")) {
System.out.println("---- Dpot un montant de
"+transaction.getMontantTransaction()+"Euros pour le
compte "+this.getNumCompte()+" au
"+transaction.getDateTransaction()+" ----");
}else if(transaction.getNomTypeTransaction().equals("retrait")) {
System.out.println("---- Retrait un montant de
"+transaction.getMontantTransaction()+"Euros pour le
compte "+this.getNumCompte()+" au
"+transaction.getDateTransaction()+" ----");
}
}else {
30

System.out.println("null");
}
}
public void printListeTransaction(String nomTypeTransaction) {
for (int i = 0; i < this.getListeTransaction().size(); i++) {
if(nomTypeTransaction.equals(this.getListeTransaction().get(i).getNomTypeTransaction(
{
if(nomTypeTransaction.equals("depot")) {
System.out.println("---- Dpot un montant de
"+this.getListeTransaction().get(i).getMontantTransaction()+"
pour le compte "+this.getNumCompte()+" au
"+this.getListeTransaction().get(i).getDateTransaction()+"
----");
}else if(nomTypeTransaction.equals("retrait")) {
System.out.println("---- Retrait un montant de
"+this.getListeTransaction().get(i).getMontantTransaction()+"
pour le compte "+this.getNumCompte()+" au
"+this.getListeTransaction().get(i).getDateTransaction()+"
----");
}
}
}
}
/**
* Cette fonction returne la liste des transaction d’un compte
*
*/
public ArrayList<Transaction> getListeTransaction() {
return this.listeTransaction ;
}
public void setListeTransaction(Transaction transaction) {
this.listeTransaction.add(transaction);
}
/**
* Cette methode calcul l’interet d’un solde
* @param taux
*/
public void setInteret() {
this.setSolde((this.getSolde()*this.getTaux())/100 + this.getSolde());
}
/**
* Cette fonction retourne le numro de compte
*/
31

public double getSolde() {
return this.solde;
}
/**
* Cette fonction retourne le taux d’interet d’un compte
*/
public int getTaux() {
return this.tauxInteret;
}
/**
*Cette fonction permet d’initialiser un numero de compte
*/
public void setNumCompte(int numcompte) {
this.numCompte = numcompte;
}
/**
* Cette fonction permet d’initialiser un solde
*/
public void setSolde(double solde) {
this.solde = solde;
}
/**
* Cette fonction retour
*/
public int getNumCompte() {
return this.numCompte;
}
/**
* Cette fonction permet d’ajouter une transaction a un compte
*
*/
public boolean setTransation(Transaction transaction) {
this.listeTransaction.add(transaction);
return true ;
}
}
//////////////////////////Transaction ////////////////////
/**
*
*/
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
32

/**
* @author sonfack
*
*/
public class Transaction {
private TypeTransaction typeTransaction ;
private Date dateTransation ;
private double montantTransaction ;
/**
* Cration d’une transaction avec un type de transaction et sans montant
* @param client
* @param compte
* @param type
* @param montant
*/
public Transaction(Client client, Compte compte, TypeTransaction type, double
montant) {
if(montant > 0) {
switch(type.getTypeTransaction()) {
case "retrait":{
if(compte.getSolde() < montant) {
System.out.println("Solde insufisant");
}else {
DateFormat dateFormat = new
SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
this.dateTransation = new Date();
// le montant doit etre positif
this.montantTransaction = montant;
this.typeTransaction = type;
// ajout de la transaction dans le compte
compte.getListeTransaction().add(this);
compte.setSolde(compte.getSolde() - montant);
System.out.println("Transaction OK");
compte.printTransaction(this);
}
break ;
}
case "depot" : {
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd
HH:mm:ss");
this.dateTransation = new Date();
// le montant doit etre positif
this.montantTransaction = montant;
this.typeTransaction = type;
// ajout de la transaction dans le compte
compte.getListeTransaction().add(this);
compte.setSolde(compte.getSolde() + montant);
System.out.println("Transaction OK");
compte.printTransaction(this);
33

break;
}
}
}else {
System.out.println("Echec transation n---- Montant nul ou
negatif ----");
}
}
/**
* Cette methode permet de retouner le nom d’une transaction
* @return nom du type de transaction
*/
public String getNomTypeTransaction() {
String nomTypeTransaction ;
nomTypeTransaction = this.typeTransaction.getTypeTransaction();
return nomTypeTransaction;
}
/**
* Cette methode permet de retourner la date d’une transaction
* @return date d’une transaction
*/
public Date getDateTransaction() {
return this.dateTransation;
}
/**
* Cette fonction permet de retourner le montant d’une transaction
* @return montant de la transaction
*/
public double getMontantTransaction() {
return this.montantTransaction ;
}
}
///////////////////////TypeTransaction //////////////////
/**
* Cette classe permet de creer des types de transaction
*/
/**
* @author sonfack
*
*/
public class TypeTransaction {
private String nomTypeTransaction ;
34

/**
* Constructeur de type de transaction
* NB: ne doit par crer une transation existante
* @param banque qui est la Banque
* @param type est le type de transaction
* Ce constructeur ajoute automatiquement le type
* de transaction dans la liste des transaction de la banque
*/
public TypeTransaction(Banque banque, String type) {
this.setTypeTransaction(type);
if(! banque.getTypeTransaction().contains(this)) {
banque.setListeTypeTransaction(this);
}
}
/**
* Cette methode permet d’affecter le nom du type de transaction
* @param type
*/
public void setTypeTransaction(String type) {
this.nomTypeTransaction = type.toLowerCase();
}
/**
* Cette methode permet de retourner le nom d’un type de transaction
* @return le nom du type de transaction
*/
public String getTypeTransaction() {
return this.nomTypeTransaction;
}
}
///////////////// Banque //////////////
/**
*
*/
package com.ckomsa.main;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import com.ckomsa.controller.Client;
import com.ckomsa.controller.Compte;
import com.ckomsa.controller.Transaction;
import com.ckomsa.controller.TypeTransaction;
import com.ckomsa.view.Menu;
35

/**
* @author sonfack
*
*/
}
/**
* Cette fonction retourne la liste des types transaction
*/
public HashSet<TypeTransaction> getTypeTransaction() {
return this.listeTypeTransaction;
}
public TypeTransaction getTypeTransaction(String nomTypeTransaction) {
TypeTransaction type = null;
for(TypeTransaction trs:this.listeTypeTransaction) {
if(trs.getTypeTransaction().equals(nomTypeTransaction)) {
type = trs;
}
}
return type;
}
/**
* recherche un client connaissant a partir de son identifiant
*/
public Client getClient(int idClient) {
Client client = null ;
if(clt.getIdClient() == idClient) {
client = clt;
}
}
return client;
}
/**
* @return the listeTypeTransaction
*/
public void setListeClient(Client client) {
int count = 0;
36

if(clt.getIdClient() != client.getIdClient()) {
count ++;
}
}
if(count >= this.listeClient.size()) {
this.listeClient.add(client);
}
}
/**
* @param
*/
public void setListeTypeTransaction(TypeTransaction typeTransaction) {
this.listeTypeTransaction.add(typeTransaction);
}
/**
* Calcule d’interet
*/
public void calculateInteret() {
if(this.listeClient.size() == 0) {
System.out.println("---- Aucun client dans la banque ----");
}else {
System.out.println("Client : "+clt.nomClient);
for(int i = 0 ; i < clt.listeCompte.size() ; i++) {
System.out.println("Numero de
complte"+clt.listeCompte.get(i).getNumCompte());
System.out.println("----Solde :
"+clt.listeCompte.get(i).getSolde()+"----");
clt.listeCompte.get(i).setInteret();
//clt.listeCompte.get(i).setSolde((clt.listeCompte.get(i).getTaux()*clt.
+ clt.listeCompte.get(i).getSolde());
System.out.println("----Nouveau solde :
"+clt.listeCompte.get(i).getSolde()+" pour
Interet : "+clt.listeCompte.get(i).getTaux()+"
----");
}
System.out.println("----------------------------------------------------------"
}
}
}
/**
*
*/
public void printListeClient() {
System.out.println(clt.nomClient);
}
}
37

/**
* Cette fonction retourn le rapport des transation de la banque
*/
public void printRapport() {
System.out.println("### Rapport des transaction de la banque ####");
System.out.println("Nom : "+clt.nomClient);
for(int index =0 ; index< clt.listeCompte.size(); index++) {
System.out.println("Compte NO: "+
clt.listeCompte.get(index).getNumCompte());
System.out.println("Sole :
"+clt.listeCompte.get(index).getSolde()+"Euros");
for(int intTrs = 0 ;
intTrs <
clt.listeCompte.get(index).getListeTransaction().size();
intTrs++) {
if(
clt.listeCompte.get(index).getListeTransaction().
get(intTrs).getNomTypeTransaction().equals("depot"))
{
System.out.println("---- Dposer un montant
de "+
getMontantTransaction()+"Euros pour le
compte "+ clt.listeCompte.
get(index).getNumCompte()+"au
"+clt.listeCompte.get(index).
}else
if(clt.listeCompte.get(index).getListeTransaction().
get(intTrs).getNomTypeTransaction().equals("retrait"))
{
System.out.println("---- Retirer un montant
de "+
clt.listeCompte.get(index).getListeTransaction().get(intTr
getMontantTransaction()+"Euros pour
le compte "+
clt.listeCompte.get(index).getNumCompte()+"au
"+clt.listeCompte.get(index).getListeTransaction().ge
}
}
}
System.out.println("n----------------------------------------n");
}
}
/**
*
38

*/
public void printListeTypeTransaction() {
for(TypeTransaction trs:this.listeTypeTransaction) {
System.out.println(trs.getTypeTransaction());
}
}
/**
* Constructeur de la classe banque
*/
public Banque() {
TypeTransaction typetransaction1 = new TypeTransaction(this, "depot");
TypeTransaction typetransaction2 = new TypeTransaction(this, "retrait");
}
/**
* @param args
*/
public static void main(String[] args) {
// TypeTransaction typeTransaction =
//System.out.println(BIDV.getTypeTransaction("depot").getTypeTransaction());
//BIDV.printListeClient();
//BIDV.getClient(1);
/*
* Client clt = new Client(BIDV, "serge0", 1);
Client clt1 = new Client(BIDV, "serge1", 1);
Compte cpt = new Compte(clt, 122);
System.out.println("///////////////////////////");
*/
try {
boolean fin = true;
do {
Menu MenuBanque = Menu.getInstanceMenu(BIDV," ");
Scanner sc =new Scanner(System.in);
try {
System.out.print("nn*Choix : ");
int choix = sc.nextInt();
if(choix < 0) {
// choix negatif
System.out.println("*Reponse : ---- Votre
choix doit etre un entier positif ----");
39

}else if(choix > 0) {
switch(choix) {
case 1 : {
MenuBanque.menuConsulteSolde(BIDV);
break;
}
case 2 : {
MenuBanque.menuCreerCompte(BIDV);
break;
}
case 3 : {
MenuBanque.menuTransaction(BIDV);
break;
}
case 4 : {
MenuBanque.menuCalculateInteret(BIDV);
break;
}
case 5 : {
BIDV.printRapport();
break ;
}
case 6 : {
MenuBanque.menuRecherche(BIDV);
break;
}
default :{
MenuBanque.messageErreur();
}
}
//MenuBanque =
Menu.getInstanceMenu(BIDV, " ");
//choix = sc.nextInt();
}else if(choix == 0) {
fin = false;
}
}catch(InputMismatchException e) {
System.out.println("*Reponse : ---- Votre choix
doit etre un entier en 0 et 6, verifiez le menu
et entrez a nouveau ----");
}
}while(fin);
BIDV.printListeClient();
}catch(Error e) {
System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
System.out.println("$$$$$$$$ Une erreur grave est survenue : " +
e+" $$$$$$$$$$");
System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
}
40

System.out.println("Programme termine");
System.exit(0);
/*try {
while(choix != 0) {
}
BIDV.printListeClient();
System.out.println("Programme termine");
System.exit(0);
}catch(InputMismatchException e) {
System.out.println("---- Votre choix doit etre un entier ----");
}
* * TypeTransaction tr1 = new TypeTransaction(BIDV, "depot");
TypeTransaction tr2 = new TypeTransaction(BIDV, "retrait");
BIDV.printListeTypeTransaction();
System.out.println("/////////");
Client clt = new Client(BIDV, "serge", 1);
Compte cpt = new Compte(clt, 122);
Compte cpt2 = new Compte(clt, 12);
Transaction tr = new Transaction(clt, cpt, tr1, 300.0);
Transaction tr00 = new Transaction(clt, cpt, tr1, 600.0);
System.out.println("/////////////////");
System.out.println(tr.getDateTransaction().toString());
System.out.println(tr.getMontantTransaction());
System.out.println("/////////////////");
System.out.println(cpt.getSolde());
// cpt.setListeTransaction(tr);
System.out.println(cpt.getListeTransaction().size());
Client clt2 = new Client(BIDV, "landry", 3);
Client clt4 = new Client(BIDV, "landry", 3);
Client clt3 = new Client(BIDV, "sylvain", 23);
*/
}
}
Lien github: www.github.com/sonfack/simple_bank
41

Rapport genie logiciel

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Rapport genie logiciel

Similaire à Rapport genie logiciel (20)

Plus de serge sonfack

Plus de serge sonfack (19)

Rapport genie logiciel