rapport du mini-projet systeme expert droits d`utilisation des logiciels

Transcription

Mini-projet Système Expert – Droits sur les logiciels
RAPPORT DU MINI-PROJET
SYSTEME EXPERT
DROITS D’UTILISATION DES
LOGICIELS
EN LISP
Elève-Ingénieur : Soufiane ATTIF
Filière :
2 GI
05/06/2006
Soufiane ATTIF 2 GI
1
1. Définition des structures :
Suite aux explications que vous m avez donné dans la dernière séance,
ai pu mettre en uvre une stratégie de raisonnement sur le projet.
Il s agit dans cette stratégie de :
Ø Déterminer le type du logiciel (freeware, shareware ou libre) en
utilisant un moteur d inférence en chaînage arrière qui au fur eu à
mesure, et selon les règles introduites, pose des questions à
utilisateur sur les droits qu il a. Il donnera en fin le type du logiciel
il arrive à le connaître en se basant sur les réponses de l utilisateur
et les règles d inférence.
Ø Vérifier les droits d utilisation pour un logiciel donné existant dans
la base des faits, et ce en se basant sur un moteur d inférence en
chaînage avant.
En ce qui suit les formalisation de la base des règles et la base des faits
stockées dans des fichiers qui doivent être dans le répertoire C:\.
§ Base des faits :
#S(LOGICIEL NOM "windows" TYP SHAREWARE DROITS
(UTILISATION))
#S(LOGICIEL NOM "linux" TYP SHAREWARE DROITS
(UTILISATION))
#S(LOGICIEL NOM "realplayer" TYP FREEWARE DROITS
(COPIE UTILISATION))
#S(LOGICIEL NOM "msn" TYP LIBRE DROITS (UTILISATION
COPIE MODIFIER))
Soufiane ATTIF 2 GI
2
§ Base des règles :
#S(REGLE RG (FREEWARE (TELECHARGÉ LICENCE)))
#S(REGLE RG (SHAREWARE (ACHETÉ LICENCE)))
#S(REGLE RG (LIBRE (TELECHARGÉ SANS_LICENCE)))
#S(REGLE RG (LICENCE (PAYER)))
§ Droits d utilisations :
#S(DROIT TYP freeware DROITS (copie utilisation))
#S(DROIT TYP shareware DROITS (utilisation))
#S(DROIT TYP libre DROITS (utilisation copie modifier))
2. Le code de l’application :
;************************ Les stream*************************
(defvar nom)
(defvar typ)
(defvar droits)
(defvar n)
(defvar tt)
(defvar d)
(defvar a)
(defvar io)
;****************Les structures****************************
(defstruct logiciel (nom "linux" :type string)
Soufiane ATTIF 2 GI
3
(typ "freeware" :type string)
(droits "copie" :type string)
)
(defstruct regle (rg "(freeware (telechargé licence))" :type string))
(defstruct droit (typ "freeware" :type string) (droits "(copie
modifier)" :type string))
;***********************************************************
;************ ***Enregistrer dans le fichier*******************
(defun logiciel(fichier)
(setq io (open fichier :direction :output :if-exists :append))
(print "Saisir les données concernant les logiciels :")(terpri)
(print "Nom :")(setq n (read))
(print "type :")(setq tt (read))
(print "droits(dans une liste) :")(setq d (read))
(setq a (make-logiciel :nom n :typ tt :droits d))
(print a io)
(close io)
)
;***********************************************************
;********* **********Afficher base de fait*******************
(defun constBF10(fichier)
(setq io (open fichier :direction :input))
(setq aff (make-instance
'capi:collector-pane
:title "Base des Faits" ))
(capi:contain aff)
(const10)
)
(defun const10()
(setq a (read io nil nil))
(cond ((not(equal a nil)) (print (list(logiciel-nom a) (logiciel-typ
a) (logiciel-droits a) )
(capi:collector-pane-stream aff)) (const10))
(t nil))
Soufiane ATTIF 2 GI
4
)
;**********************************************************
;************ ******Afficher base des règles******************
(defun constBR11(fichier)
(setq tio (open fichier :direction :input))
(setq aff1 (make-instance
'capi:collector-pane
:title "Base des Règles" ))
(capi:contain aff1)
(const11)
)
(defun const11()
(setq a (read tio nil nil))
(cond ((not(equal a nil)) (print (regle-rg a)
(capi:collector-pane-stream aff1)) (const11))
(t nil))
)
;***********************************************************
;****** ******Construction de la base de faits*****************
(defun constBF(fichier)
(const nil)
)
(defun const(liste)
(cond ((not(equal a nil)) (const (cons (logiciel-nom a) liste)))
(t liste))
)
;**********************************************************
Soufiane ATTIF 2 GI
5
;********** Afficher les droits d'un logiciel donné***********
(defun listdroit(fichier logiciel)
(rech_droit logiciel)
)
;***********************************************************
;******* ******rechercher les droits d'un logiciel*************
(defun rech_droit(logiciel)
(cond ((equal (logiciel-nom a) logiciel) (logiciel-droits a))
(t (rech_droit logiciel))
)
)
;**********************************************************
;******* **************memberp**************************
(defun memberp(x l)
(cond ((null l) nil)
((equal x (car l)) l)
(t (memberp x (cdr l)))
)
)
;**********************************************************
;******** **************Commencement*****************
(defvar choix)
(defvar But)
(defvar BFLog)
(defvar BF)
(defvar BR)
(defun logiciel()
(setq log (make-instance
'capi:text-input-pane
:title "Donner le nom du logiciel :"
:text ""
:callback #'(lambda (text interface)
(setq But text)
(setq BFLog (constBF "c:\faits.txt"))
Soufiane ATTIF 2 GI
6
(cond ((memberp but BFLog) (setq drt (listdroit "c:\faits.txt"
but)) (capi:display-message "Les droits que vous avez su le logiciel :
~S sont : ~S" but drt) )
(t
(terpri)
(setq BR (constBR "c:\regles.txt"))
(chain_arr '(freeware shareware libre) nil BR)
)
)
)))
(capi:contain log)
)
(defun logiciel2()
(capi:contain (make-instance
:title "Donner le nom du logiciel :"
:text ""
(setq logic text)
:title "Donner le droit à vérifier dans une liste :"
:text ""
(setq Butss (prog1 (read-from-string text )))
(setq BFLog2 (constBF "c:\faits.txt"))
(cond ((memberp logic BFLog2) (setq drt (listdroit "c:\faits.txt"
logic))
(cond ((memberp butss drt)
(capi:display-message "Le droit ~S est vérifié au logiciel ~S" butss
logic)) (t
(capi:display-message "Le droit ~S n'est pas vérifié au logiciel ~S"
butss logic)
)))
Soufiane ATTIF 2 GI
7
(t (capi:display-message "Le logiciel ~S n'est pas dans la base
des faits" logic)
)
)
)
)))
;(capi:contain log)
)
))
;*********** *********Moteur d'inférence**************
;BR=Base des Règles
;BF=Base des Faits
;F=Fait
;R=Règle
;P=Premisse
;SB=Sous But
;LB=Liste Buts
;il faut initialiser Stk_Rgl à nil
;Traitement d'un but
(defvar R)
(defvar P)
(defvar SB)
(defun trait_but1(but BF BR Stk_Rgl)
(cond ((null BR) (princ "Echec ") (princ but)(terpri))
;sinon
(t (setq R (car BR))
(setq P (cadr R))
(setq SB (car R))
(cond ((regle_fait R BF) ;verifie si la regle est satisfaite meme
avec plusieurs arguments
(cond ((equal SB but) (princ "succès : ") (prin1 but)
(terpri))
;sinon
(t (trait_but1 but (cons SB BF) (append Stk_Rgl (cdr
BR)) nil))
)
Soufiane ATTIF 2 GI
8
)
)
)
;sinon
(t (trait_but1 but BF (cdr BR) (append (list R) Stk_Rgl)))
)
)
(defun chain_avant(LB BF BR)
(cond ((null LB) nil)
((memberp (car LB) BF) (princ "succès BF : ") (prin1 (car
LB)) (terpri) (chain_avant (cdr LB) BF BR))
(t (trait_but1 (car LB) BF BR nil) (chain_avant (cdr LB)
BF BR))))
(defun regle_fait(regle BF)
(cond ((null (cadr regle)) (car regle))
((memberp (caadr regle) BF) (regle_fait (append (list(car
regle)) (list(cdadr regle))) BF))
(t nil))
)
(defun supp_elt_liste(elt source cible)
(cond ((equal (car source) elt) (append cible (cdr source)))
(t (supp_elt_liste elt (cdr source) (append cible (list(car
source)))))
)
)
;Fonction qui determine toutes les règles qui satisfont un but
;LR = Liste de Règles qui satisfont le but
(defun satisfait_regles_but(but BR)
(cond ((equal (caar BR) but) BR)
Soufiane ATTIF 2 GI
9
((null BR) nil)
(t (satisfait_regles_but but (cdr BR)))
)
)
;LB = Liste de buts initié par un seul but
(defvar LR)
(defvar SB)
(defvar LRC)
(defvar rep)
(defun trait_but(but_base LB BF BR Stk_Rgl)
(cond ((null LB) (satis_type "c:\droits.txt" "c:\faits.txt" but
but_base))
((memberp (car LB) BF) (trait_but but_base (cdr LB) BF BR
Stk_Rgl))
((assoc (car LB) BR)
(setq LR (satisfait_regles_but (car LB) BR))
(setq LRC (satisfait_regles_but (car LB) (cdr LR)))
(setq R (car LR))
(cond
((null LR) (cond ((null Stk_Rgl) (capi:displaymessage "Echec"))
(t (trait_but but_base (cadar Stk_Rgl)
BF
(supp_elt_liste (caar
Stk_Rgl) BR nil) (cdr Stk_Rgl)))))
(t (if (not(null LRC)) (setq Stk_Rgl (append
(list(append (list(car LR)) (list LB))) Stk_Rgl)))
(setq SB (cadar LR))
(trait_but but_base (append SB (cdr LB)) BF BR Stk_Rgl)
)
)
)
Soufiane ATTIF 2 GI
10
(t ;(print (car LB))(princ " oui/!?")
:title (string (car LB))
:text "oui ou ! ?"
(setq rep text)
(cond
((equal rep "oui") (trait_but but_base (cdr LB) (cons
(car LB) nil) BR Stk_Rgl))
(t
(setq LR (satisfait_regles_but (car LB) BR))
(setq LRC (satisfait_regles_but (car LB) (cdr LR))) ;(print
(satisfait_regles_but (car LB) (cdr LR)))
(setq R (car LR))
(cond
((null LR) (cond ((null Stk_Rgl) (capi:display-message
"Echec") )
(t (trait_but but_base (cadar Stk_Rgl) BF
(supp_elt_liste (caar Stk_Rgl) BR nil) (cdr Stk_Rgl)))))
(t (if (not(null LRC)) (setq Stk_Rgl (append (list(append
(list(car LR)) (list LB))) Stk_Rgl)))
(setq SB (cadar LR))
(trait_but but_base (append SB (cdr LB)) BF BR Stk_Rgl)
)
)
)
))))
)))
(defun chain_arr(Buts BF BR)
(cond ((null Buts) nil );(capi:display-message "Fin du traitement"))
(t (setq BFLog (constBF "c:\faits.txt"))
(cond ((not(memberp but BFLog))
Soufiane ATTIF 2 GI
11
(capi:display-message "But à montrer : ~S" (car Buts))
(trait_but (car Buts) (list(car Buts)) BF BR nil) (chain_arr (cdr Buts)
BF BR)
)
(t nil))
)
)
)
;**********************************************************
;************** Ajouter une règle**********************
(defvar tio)
(defvar texte_ft)
(defun ajft()
(setq texte_ft1 (make-instance
:title "Nom du logiciel :"
:text ""
(setq nm text))))
:title "Type du logiciel :"
:text ""
(setq tp text))))
:title "Liste des droits :"
:text ""
Soufiane ATTIF 2 GI
12
(setq dr text)
(setq tio (open "c:\faits.txt" :direction :output
:if-exists :append))
dr ))
(setq a (make-logiciel :nom nm :typ tp :droits
(print a tio)
(close tio)
)))
(setq titre_ft (make-instance 'capi:title-pane
:text "Système Expert"
:font (gp:make-font-description
:size 20
)))
(setq var_ft (make-instance 'capi:column-layout
:description (list titre_ft texte_ft1 texte_ft2 texte_ft3)))
(capi:contain var_ft)
)
;************************************************************
;************ * ***Ajouter une règle*************************
(defvar rio)
(defvar texte_rg)
(defun aj()
(setq texte_rg (make-instance
:title "Règle(A (b c ...)) :"
:text ""
(setq rio (open "c:\regles.txt" :direction
:output :if-exists :append))
(setq q (prog1 (read-from-string text )))
(setq a (make-regle :rg q ))
Soufiane ATTIF 2 GI
13
(print a rio)
(close rio)
)))
(capi:contain texte_rg)
)
(defun convert (string)
(intern (string-upcase string)))
;**********************************************************
;** Construction de base règles(afficher la base de règles)**
(defun constBR(fichier)
(setq rio (open fichier :direction :input))
(const2 nil)
)
(defun const2(liste)
(setq a (read rio nil nil))
(cond ((not(equal a nil)) (const2 (cons (regle-rg a) liste)))
(t liste))
)
;********************************************************
;* ************Satisfaction de type de logiciel**************
(defun satis_type(fichier fichier2 logiciel type)
(setq d (rech_droit2 type))
(setq rio (open fichier2 :direction :output :if-exists :append))
(setq a (make-logiciel :nom logiciel :typ type :droits d))
(print a rio)
(close rio)
(capi:display-message "vos droits sont : ~S" d)
)
(defun rech_droit2(type)
Soufiane ATTIF 2 GI
14
(cond ((equal (droit-typ a) type) (droit-droits a))
(t (rech_droit2 type))
)
)
;*********************************************************
;********* *************Interfaces**************************
;************* **** Interface 1 ******************************
(setq btn1 (make-instance 'capi:push-button
:data "Base des règles"
:callback '(int2)))
:data "Base des faits"
:callback '(int3)))
:data "Inférence"
:callback '(int4)))
; :data "quitter"
:descriptor "Stop"
:callback 'quit))
(setq titre (make-instance 'capi:title-pane
:text "Système Expert"
:background :blue
:foreground :yellow
:size 20
)
))
Soufiane ATTIF 2 GI
15
(setq var1 (make-instance 'capi:column-layout
:description (list titre btn1 btn2 btn3 btn4)))
(defun int1()
(capi:contain var1))
;************************************************************
******************************************************
;****************************************Interface 2
*************************************************************
:data "Ajouter une règle"
:callback '(aj)))
:data "Afficher la base des règles"
:callback '(constBR11 "c:\regles.txt")))
:data "Retour au menu principal"
:callback '(aju)))
(setq titre1 (make-instance 'capi:title-pane
:text "Base des Règles"
:background :blue
:foreground :yellow
:size 20
)
))
:description (list titre1 btn5 btn6 btn7 )))
Soufiane ATTIF 2 GI
16
(defun int2()
;*******************************************************
;********** **************Interface 3 ********************
:data "Ajouter un fait"
:callback '(ajft)))
:data "Afficher la base des faits"
:callback '(constBF10 "c:\faits.txt")))
:callback '(aju)))
:text "Base des Faits"
:background :blue
:foreground :yellow
:size 20
)
))
:description (list titre2 btn8 btn9 btn10 )))
(defun int3()
;**********************************************************
Soufiane ATTIF 2 GI
17
;*************** *******Interface 4 *************************
:data "Chainage arrière"
:callback '(logiciel)))
:data "Chainage avant"
:callback '(logiciel2)))
:callback '(ajt2)))
:text "Inférence"
:background :blue
:foreground :yellow
:size 20
)
))
:description (list titre3 btn11 btn12 btn13)))
(defun int4()
;********************************************************************
Soufiane ATTIF 2 GI
18
Jeux de tests:
Appel à la fonction principale se fait par la fonction : (int1) .
Après, il y a une interactivité totale entre l utilisateur et le
programme grâce à des interfaces.
A chaque fois après la saisie d une donnée, il faut taper entrer
pour que la fonction liée à la saisie s exécute.
Il faut que les fichiers « faits.txt », « regles.txt » et droits.txt »
soient stockés dans le répertoire C:\.
explication au niveau du moteur d inférence se fait par le biais
des boites de dialogues qui informent l utilisateur de l état courant et s il y
a un échec ou pas.
Tous les modules ont été testés. Je reste à votre entière disposition
pour toute autre clarification.
En ce qui suit, quelques images illustrant le processus d exécution.
Soufiane ATTIF 2 GI
19
Soufiane ATTIF 2 GI
20
Soufiane ATTIF 2 GI
21

rapport du mini-projet systeme expert droits d`utilisation des logiciels

Transcription

Documents pareils

Fermeture au public des piscines de la CAPI

AD 3.HSTB

10_2012 - Meyrié

Comment venir au Parc des Expositions…

Alice FERNEY - L`Isle d`Abeau

LESPARRE SAINT LAURENT MEDOC AD2 LFDU ATT 01

RivesActu n°57 - Banque Populaire Rives de Paris

APPROCHE A VUE Visual approach 01 CHÂTEAUNEUF DU

AD 2.LFJU AD 2 LFJU ATT 01 AD 2 LFJU TXT 01