Commentçamarche.net
CodeS-SourceS
Rechercher un code, un tuto, une réponse

Gestion d'un restaurant

0/5 (5 avis)

Vue 21 438 fois - Téléchargée 2 616 fois

Description

Mon logiciel s'adapte à tous commerces. specialement dans la restauration rapide. (pizzaria,kebab...)
il vous permet de :
- saisir de commandes
- rechercher des commandes
- éditer le chiffre d'affaire journalié
- créer des produits
- savoir commbien chaque vendeur a encaissé
- les produits à faire
- initiatialiser les fichiers nécessaires

Source / Exemple :


unit  U_pizzaria;

interface

uses  SysUtils,
      crt,
      mes_outils;

const nb_max_pizza         = 30;
      nb_max_de_commande   = 250;
      nb_max_de_clients    = 100;
      tva                  = 0.055;
      file_commande        = 'mina.jul';
      file_commande_annulee= 'cmd_annulee_modifiee.jul';
      file_client          = 'nos_clients.jul';
      file_produit         = 'nos_produits.jul';
type  type_prix            = real;
      T_pizza = record
           code            : string[4];
           libelle         : string[15];
           quantite        : BYTE;
           prix            : type_prix;
           end{record};
      T_tab_pizza          = array[1..nb_max_pizza] of T_pizza;
      T_les_pizzas         = record
           nb_pizza        : byte;
           les_pizzas      : T_tab_pizza;
      end {record};

      la_commande = record
           les_pizzas      : T_tab_pizza;
           nb_de_pizza     : byte;
      end {record};

      T_client = record
           num_tel         : string[10];
           nom             : string[10];
           adresse         : string[26];
           nb_cmd_effectuer: byte;
           commande_client : la_commande;
      end{record};

      T_tab_client         = array[0..nb_max_de_clients] of T_client;
      T_les_clients        = record
           nb_client       : byte;
           les_clients     : T_tab_client;
      end{record};

      T_commande = record
           code_vendeur    : string[4];
           le_client       : T_client;
           prix_total      : type_prix;
           date_commande   : STRING[12];
           heure_commande  : tdatetime;
      end{record};

      T_tab_commande       = array[0..nb_max_de_commande] of t_commande;
      T_les_commandes      = record
           nb_commande     : byte;
           les_commandes   : T_tab_commande;
      end {record};
      fichier_client       = file of T_client;
      fichier_commande     = file of T_commande;
      fichier_produit      = file of T_pizza;

////////////------ LES VARIABLES GLOBALES ----------////////////
                                                              //
var   objet                : fichier_commande;                //
      objet_client         : fichier_client;                  //
      objet_produit        : fichier_produit;                 //
      com                  : T_commande;                      //
      client               : T_client;                        //
////////////////////////////////////////////////////////////////

procedure initialiser_fichier(file_name: string);
procedure initialisation;
procedure ajouter_produit;
procedure fiche_vide(num_commande : SMALLINT);
procedure fiche_vide0;
procedure afficher_prix(out piz : T_pizza;i: byte);
procedure a_faire(phrase : string);
procedure efface_ecran;
procedure fiche_encaissement;
procedure rechercher_commande;
procedure recherche_par_date;
procedure saisir_commande(out comm : T_commande);
procedure afficher_commande(num_cmd: cardinal);
procedure decaisser_vendeur;
procedure pizza_a_faire;
procedure menu;
procedure ecrir_fichier (commande : T_commande);
procedure fermer_fichier(file_name : string);
procedure ouvrir_fichier(file_name : string);
procedure ajouter_client (client : T_client);
procedure modifier_client(num_tel : string) ;
procedure afficher_les_clients;
procedure journal;
procedure sous_menuR;
procedure sous_menuS;
procedure annuler_commande(num_cmd: cardinal);
procedure modifier_commande(num_cmd: cardinal);
procedure commande_precedente(var num_cmd: cardinal);
procedure commande_suivante(var num_cmd: cardinal);

function  est_pizza(const code : string) : boolean;
function  est_valable(const s : string): boolean;
function  est_client (numero_tel : string) : boolean;
function  lire_nos_pizzas(file_produit: string) : T_les_pizzas;
function  lire_une_commande (num_commande : integer) :T_commande;
function  lire_les_commandes_du_jour (la_date : string):T_les_commandes;
function  lire_les_clients(file_client: string) : T_les_clients;
function  lire_un_client (numero_tel: string) : T_client;
function  formatage_fichier (file_name : string):T_les_commandes;
function  nb_total_commande(file_commande : string): byte;

implementation

procedure initialiser_fichier(file_name: string);
begin
        assign(objet,file_name);
        rewrite(objet);
        close(objet);
        a_faire('Fichiers initialises "Enter" pour retourner au Menu principal !');

end{initaliser_fichiers};

procedure initialisation;

Var     reponse : char;
label   la;
procedure fiche;
begin
        efface_ecran;
        un_rectangle(5,5,58,20);
        un_rectangle(5,7,58,20);
        gotoxy(8,6);write('INITIALISATIONS DES FICHIERS');
        gotoxy(7,9);write('1 - TOUS LES FICHIERS');
        gotoxy(7,11);write('2 - FICHIER DES CLIENTS ');
        gotoxy(7,13);write('3 - FICHIER DES PRODUITS ');
        gotoxy(7,15);write('4 - FICHIERS DES COMMANDES');
        gotoxy(7,17);write('5 - FICHIERS DES COMMANDES ANNULEES OU MODIFIEES');
        gotoxy(7,19);write('6 - MENU PRINCIPAL');
        a_faire('Appuyer sur un numero pour initialiser le fichier correspondant !');

end{fiche_produit};

begin
        fiche;
        la:  reponse:=readkey;
        case reponse of
                '1' :   BEGIN
                          initialiser_fichier(file_client);
                          initialiser_fichier(file_produit);
                          initialiser_fichier(file_commande);
                          initialiser_fichier(file_commande_annulee);
                          a_faire('Fichiers initialises');
                          READLN;
                          menu;
                        END;

                '2' :   BEGIN
                        initialiser_fichier(file_client);
                        readln;
                        end;
                '3' :   begin
                        initialiser_fichier(file_produit);
                        readln;
                        end;
                '4' :   begin
                        initialiser_fichier(file_commande);
                        readln;
                        end;

                '5' :   begin
                        initialiser_fichier(file_commande_annulee);
                        readln;
                        end;
                '6' : menu;
                else goto la ;
        end {case};

end{initialisation};

procedure ajouter_produit;

var
        reponse : char;
label   ici, labas;

        Procedure fiche_produit;
        begin
                efface_ecran;
                un_rectangle(5,5,40,20);
                un_rectangle(5,7,40,20);
                gotoxy(8,6);write('A J O U T E R    P R O D U I T');
                gotoxy(6,9);write('CODE PRODUIT :');
                gotoxy(6,11);write('NOM  PRODUIT :');
                gotoxy(6,13);write('PRIX PRODUIT :');
        end{fiche_produit};

        procedure saisir_produit;
        var pizz: T_pizza;
        begin
                fiche_produit;
                assign(objet_produit,file_produit);
                reset(objet_produit);
                repeat
                  a_faire('Entrer le code du Produit ou Q pour Quitter ');
                  gotoxy(21,9);readln(pizz.code);
                  if  (pizz.code ='Q') or (pizz.code ='q')  then begin
                     exit;
                  end;
                until pizz.code<>'';
                repeat
                  a_faire('Entrer le libelle du Produit ou Q pour Quitter ');
                  gotoxy(21,11);readln(pizz.libelle);
                  if  (pizz.libelle='Q') or (pizz.libelle='q') then begin
                     exit;
                  end;
                until pizz.libelle<>'';
                a_faire('Entrer le Prix du Produit ou Q pour Quitter ');
                gotoxy(21,13);readln(pizz.prix);
                seek(objet_produit,filesize(objet_produit));
                write(objet_produit,pizz);
                close(objet_produit);
                ajouter_produit;
        end{saisir_produit};

        procedure rechercher_produit;
        var pizz: T_pizza;
            code :string;

        begin
                fiche_produit;
                repeat
                  a_faire('Entrer le code du Produit ou Q pour Quitter ');
                  gotoxy(21,9);readln(code);
                  if  (code ='Q') or (code ='q')  then begin
                     ajouter_produit;
                  end;
                  until pizz.code<>'';
                  if est_pizza(code) then begin
                     assign(objet_produit,file_produit);
                     reset(objet_produit);
                     while not eof(objet_produit) do begin
                        read(objet_produit,pizz);
                        if code=pizz.code then begin
                            gotoxy(21,11);write(pizz.libelle);
                            gotoxy(21,13);write(pizz.prix:0:2);

                        end{if};
                     end{while};
                     close(objet_produit);
                  end else begin
                  a_faire('Ce produit n''existe pas ! ');

                  end;

                 readln;
                 a_faire('Appuyer sue " Enter " pour continuer...');
                 ajouter_produit;
        end{saisir_produit};

begin

        labas:
        efface_ecran;
        fiche_produit;
        a_faire(' ');
        gotoxy(8,18);write('1- Creer  2- Recherche 3-Menu');
        reponse:=readkey;
        case upcase(reponse) of
                'C','1',#13 : saisir_produit;
                'R','2' : rechercher_produit;
                'M','3' : menu;
                else goto labas;
        end{case};

end{ajouter_produit};

function lire_nos_pizzas(file_produit: string) : T_les_pizzas;
var     i               : integer;
        nos_pizzas      : T_les_pizzas;
        pizza           : T_pizza;

begin
        assign(objet_produit,file_produit);
        reset(objet_produit);
        i:=0;
        nos_pizzas.nb_pizza :=0;
        while not (eof(objet_produit)) do begin
                inc(nos_pizzas.nb_pizza);
                seek(objet_produit,i);
                read(objet_produit,pizza);
                nos_pizzas.les_pizzas[nos_pizzas.nb_pizza]:=pizza;
                inc(i);

        end{while};
        lire_nos_pizzas := nos_pizzas;
        close(objet_produit);

end {lire_nos_pizzas};

function est_pizza(const code : string) : boolean;
var
        pizza           : T_pizza;
        resultat        : boolean;

begin
        assign(objet_produit,file_produit);
        reset(objet_produit);
        resultat:=false;

        while not (eof(objet_produit)) do begin
                read(objet_produit,pizza);
                resultat:= resultat or (code=pizza.code);
        end{while};
        close(objet_produit);
        est_pizza:= resultat;

end {est_pizza};

procedure annuler_commande(num_cmd: cardinal);
var cmd         : T_commande;
     reponse    : char;
begin

        a_faire('Confirmer l''annulation de la Commande (O) ou (N)');
        reponse:=readkey;
        case upcase(reponse) of
        'O',#13 : begin
               cmd:= lire_une_commande(num_cmd);
               cmd.prix_total:=0;
               cmd.le_client.commande_client.nb_de_pizza:=0;
               ouvrir_fichier(file_commande);
               seek(objet,num_cmd-1);
               write(objet,cmd);
               fermer_fichier(file_commande);
               menu;
              end;
        'N' : saisir_commande(com);
        else  saisir_commande(com);
        end{case};
end{annuler_commande};

procedure modifier_commande(num_cmd: cardinal);
var     cmd     : T_commande;
        reponse : char;
label   labas,la,ici;
begin

        gotoXY(11,13);write('Appuyer sur ''ENTREE'' pour modifier la commande');
        gotoXY(11,14);write('Appuyer sur une touche pour aller au Menu principal');
        reponse := readkey;
        case reponse of
                #13 : goto ici;
                else  BEGIN
                                gotoXY(11,13);write('                                                ');
                                gotoXY(11,14);write('                                                   ');
                                GOTO labas;
                      END;
        end{case};
        ici:
        gotoXY(11,13);write('                                                ');
        gotoXY(11,14);write('                                                   ');
        afficher_commande(num_cmd);
        cmd := lire_une_commande(num_cmd);
        with cmd do begin
                with le_client do begin

                        prix_total:=0;
                        commande_client.nb_de_pizza:=1;
                        la:
                        a_faire('Entrer le code du produit ou ''V'' pour Valider ''Q'' pour Quitter');
                        gotoxy(7,20+commande_client.nb_de_pizza);

                        readln(commande_client.les_pizzas[commande_client.nb_de_pizza].code);
                        if (commande_client.les_pizzas[commande_client.nb_de_pizza].code=('q'))
                         or (commande_client.les_pizzas[commande_client.nb_de_pizza].code=('Q'))
                         then
                         begin
                           sous_menuS;
                           exit;
                         end;
                        while (commande_client.les_pizzas[commande_client.nb_de_pizza].code<>'V')
                                or
                                (commande_client.nb_de_pizza=nb_max_pizza) do begin
                                if not est_pizza(commande_client.les_pizzas[commande_client.nb_de_pizza].code) then begin
                                        gotoxy(7,20+commande_client.nb_de_pizza);
                                        write('    ');
                                        gotoxy(7,20+commande_client.nb_de_pizza);
                                        goto la;
                                        end else begin
                                                afficher_prix(commande_client.les_pizzas[commande_client.nb_de_pizza],commande_client.nb_de_pizza);
                                                prix_total := prix_total +
                                                (commande_client.les_pizzas[commande_client.nb_de_pizza].prix *
                                                commande_client.les_pizzas[commande_client.nb_de_pizza].quantite);
                                                inc(commande_client.nb_de_pizza);
                                                gotoxy(60,40);writeln(prix_total:0:2);
                                                a_faire('Entrer le code du produit ou ''V'' pour Valider ''Q'' pour Quitter');
                                                gotoxy(7,20+commande_client.nb_de_pizza);
                                                readln(commande_client.les_pizzas[commande_client.nb_de_pizza].code);
                                                if (commande_client.les_pizzas[commande_client.nb_de_pizza].code=('q'))
                                                    or (commande_client.les_pizzas[commande_client.nb_de_pizza].code=('Q'))
                                                then
                                                begin
                                                   sous_menuS;
                                                   exit;
                                                end;
                                end{if};
                        end{while};
                        ouvrir_fichier(file_commande);
                        seek(objet,num_cmd-1);
                        write(objet,cmd);
                        fermer_fichier(file_commande);
                        labas:
                        a_faire('1-Creer  2-Modifier   3-Annuler  4-Precedente   5-Suivante  6-mEnu');
                        reponse := readkey;
                        case upcase(reponse) of
                                '1','C',#13 : saisir_commande(cmd);
                                '2','M' : modifier_commande(num_cmd);
                                '3','A' : annuler_commande(num_cmd);
                                '4','P' : commande_precedente(num_cmd);
                                '5','S' : commande_suivante(num_cmd);
                                '6','E' : menu;
                                else goto labas;
                        end;

                end {with le_client};
        end {with cmd};

end{modifier_commande};

procedure commande_precedente(var num_cmd: cardinal);
label
        labas;
var
        reponse : char;
begin
        efface_ecran;
        case num_cmd of
                1 :     begin
                                num_cmd:=nb_total_commande(file_commande)-1;
                                afficher_commande(num_cmd);
                        end;
                        else  begin
                                dec(num_cmd);
                                afficher_commande(num_cmd);
                        end;
        end{case};
        labas:
        a_faire('1-Creer   2-Modifier   3-Annuler  4-Precedente   5-Suivante  6-mEnu');
        reponse := readkey;
        case upcase(reponse) of
                '1','C',#13 : saisir_commande(com);
                '2','M' : modifier_commande(num_cmd);
                '3','A' : annuler_commande(num_cmd);
                '4','P' : commande_precedente(num_cmd);
                '5','S' : commande_suivante(num_cmd);
                '6','E' : menu;
                else goto labas;
        end{case};

 end{commande_precedente};

procedure commande_suivante(var num_cmd: cardinal);
label
        labas;
var
        reponse : char;
        n       : byte;
begin
        efface_ecran;
        n :=nb_total_commande(file_commande)-1;
        if num_cmd = n then begin
                num_cmd:=1;
                afficher_commande(num_cmd);
                end else begin
                inc(num_cmd);
                afficher_commande(num_cmd);
        end{if};

        labas   :
        a_faire('1-Creer   2-Modifier   3-Annuler  4-Precedente   5-Suivante  6-mEnu');
        reponse := readkey;
        case upcase(reponse) of
                '1','C',#13 : saisir_commande(com);
                '2','M' : modifier_commande(num_cmd);
                '3','A' : annuler_commande(num_cmd);
                '4','P' : commande_precedente(num_cmd);
                '5','S' : commande_suivante(num_cmd);
                '6','E' : menu;
                else goto labas;
        end{case};

end{commande_suivante};

procedure ecrir_fichier (commande : T_commande);

begin
        assign(objet,file_commande);
        reset(objet);
        seek(objet,filesize(objet));
        write(objet,commande);
        close(objet);
end{ecrir_fichier };

procedure ouvrir_fichier ;

begin
        assign(objet,file_name);
        reset(objet);

end{ouvrir_fichier};

function nb_total_commande(file_commande : string): byte;
var
        n       : byte;
begin
        assign(objet,file_commande);
        reset(objet);
        n := filesize(objet)+1;
        close(objet);
        nb_total_commande := n;
end{num_commande};

procedure fermer_fichier ;
begin
        assign(objet,file_name);
        reset(objet);
        close(objet);
end{fermer_fichier };

function lire_une_commande(num_commande : integer) : T_commande;

var
        commande: T_commande;
begin

        assign(objet,file_commande);
        reset(objet);
        seek(objet,num_commande-1);
        read(objet,commande);
        lire_une_commande := commande;
        close(objet);

end{lire_une_commande };

function formatage_fichier (file_name : string):T_les_commandes;

var
        une_com : T_les_commandes;
        com     : T_commande;
        i       : integer;
begin
        assign(objet,file_name);
        reset(objet);
        i:=0;
        while not(eof(objet)) do begin
                seek(objet,i);
                read(objet,com);
                une_com.les_commandes[i]:=com;
                inc(i);
        end{while};
        une_com.nb_commande:=filesize(objet)+1;
        formatage_fichier := une_com;
        close(objet);
end{formatage_fichier};

function lire_les_clients(file_client: string) : T_les_clients;
var
        clients         : T_les_clients;
        i               : integer;
        un_client       : T_client;

begin
        assign(objet_client,file_client);
        reset(objet_client);
        clients.nb_client := filesize(objet_client);
        i:=0;
        while not(eof(objet_client)) do begin
                seek(objet_client,i);
                read(objet_client,un_client)  ;
                clients.les_clients[i]:=un_client;
                inc(i);
        end{while};
        lire_les_clients := clients;
        close(objet_client);
end{lire_les_clients};

function est_client (numero_tel: string) : boolean;
var
        resultat: boolean;
        clients : T_les_clients;
        i       : integer;
begin
        resultat := false;
        clients := lire_les_clients(file_client);
        for i:=0 to clients.nb_client do begin
                if numero_tel = clients.les_clients[i].num_tel then begin
                        resultat := true;
                end{if};
        end{for};
        est_client :=resultat;
end{est_client};

function lire_un_client (numero_tel: string) : T_client;
var
        clients : T_les_clients;
        i       : integer;
begin
        clients := lire_les_clients(file_client);
        for i:=0 to clients.nb_client do begin
                if numero_tel = clients.les_clients[i].num_tel then begin
                        client:=clients.les_clients[i];
                end{if};
        end{for};
        lire_un_client := client;
end{est_client};

procedure modifier_client(num_tel : string) ;
var
        i       : integer;
        client  : T_client;

begin
        assign(objet_client,file_client);
        reset(objet_client);
        i:=0;
        while not(eof(objet_client)) do begin
                seek(objet_client,i);
                read(objet_client,client)  ;
                if client.num_tel=num_tel then begin
                        writeln('numeror telephone : ',num_tel);
                        writeln('nom: ',client.nom);
                        writeln('adresse: ',client.adresse);
                        writeln('+++++++++++++++++++++++++++++++++++++++++++++');
                        writeln('numeror telephone : ',num_tel);
                        write('nom: ');readln(client.nom);
                        write('adresse: ');readln(client.adresse);
                        seek(objet_client,i);
                        write(objet_client,client);
                        exit;
                end{if};
                inc(i);
        end{while};
        close(objet_client);

end{modifier_client};

procedure modifier_nb_cmd_effectue(num_tel:string;n:smallint) ;
var
        i       : integer;
        client  : T_client;

begin
        assign(objet_client,file_client);
        reset(objet_client);
        i:=0;
        while not(eof(objet_client)) do begin
                seek(objet_client,i);
                read(objet_client,client)  ;
                if client.num_tel=num_tel then begin
                        client.nb_cmd_effectuer:=n;
                        seek(objet_client,i);
                        write(objet_client,client);
                        exit;
                end{if};
                inc(i);
        end{while};
        close(objet_client);

end{modifier_nb_cmd_effectue};

procedure afficher_les_clients ;
var
        i       : integer;
        client  : T_client;

begin
        assign(objet_client,file_client);
        reset(objet_client);
        i:=0;
        while not(eof(objet_client)) do begin
                seek(objet_client,i);
                read(objet_client,client)  ;
                writeln('numeror telephone : ',client.num_tel);
                writeln('nom: ',client.nom);
                writeln('adresse: ',client.adresse);
                writeln('+++++++++++++++++++++++++++++++++++++++++++++');
                inc(i);
        end{while};
        READLN;
        close(objet_client);

end{afficher_les_clients};

procedure ajouter_client (client : T_client);
begin
        assign(objet_client,file_client);
        reset(objet_client);
        seek(objet_client,filesize(objet_client));
        write(objet_client,client);
        close(objet_client);
end{ajouter_client};

function lire_les_commandes_du_jour (la_date : string):T_les_commandes;

var     resultat: T_les_commandes;

        objet           : fichier_commande;
        commande        : T_commande;
begin

        assign(objet,file_commande);
        reset(objet);
        resultat.nb_commande:=0;
        while not eof(objet) do begin
         read(objet,commande);
         if commande.date_commande=la_date then  begin
            inc(resultat.nb_commande);
            resultat.les_commandes[resultat.nb_commande]:=commande;
         end{if};
        end{for};
        lire_les_commandes_du_jour := resultat;

end{lire_les_commandes_du_jour};

procedure journal;

type
        T_chiffre_daffaire = record
                nb_commandes : byte;
                montant      : real;
        end{record};

var
        toutes_les_commandes                    : T_les_commandes;
        i                                       : byte;
        ca_emporter,ca_livraison                : T_chiffre_daffaire;
        chiffre_daffaire_ttc,chiffre_daffaire_ht: real;
        reponse                                 : char;
label
        ici,labas;
procedure trace_du_journal;
begin
        un_rectangle(11,5,70,45);
        un_rectangle(11,10,70,30);
        un_rectangle(11,10,70,12);
        un_rectangle(40,10,55,30);
        gotoXY(20,7);write('J O U R N A L');
        gotoXY(14,17);write('CHIFFRE D''AFFAIRE V.A.E');
        gotoXY(14,22);write('CHIFFRE D''AFFAIRE L.A.D');
        gotoXY(17,35);write('CHIFFRE D''AFFAIRE H.T');
        gotoXY(17,39);write('CHIFFRE D''AFFAIRE T.T.C');
        un_rectangle(50,34,68,36);
        un_rectangle(50,38,68,40);
        gotoXY(41,11);write('Nbre Commandes');
        gotoXY(56,11);write('Montant total');
        gotoXY(52,42);write('T.V.A = ',tva*100:0:2,' %');
end{trace_du_journal};

var     la_date : string[10];
begin
        ici:
        efface_ecran;
        trace_du_journal;
        ca_emporter.nb_commandes:=0;
        ca_emporter.montant:=0;
        ca_livraison.nb_commandes:=0;
        ca_livraison.montant:=0;
        un_rectangle(48,6,68,8);
        gotoXY(13,11);write('HEURE :');
        gotoXY(21,11);WRITE(timetostr(time));
        gotoXY(50,7);write('DATE :',datetostr(date));
        a_faire('Entrer une date pour afficher le Journal ');
        gotoXY(56,7);readln(la_date);
        if la_date ='' then begin
                toutes_les_commandes:=lire_les_commandes_du_jour(datetostr(date));
                end else  begin
                toutes_les_commandes:=lire_les_commandes_du_jour(la_date);
        end{if};
        a_faire(' ');
        for i:=1 to toutes_les_commandes.nb_commande do begin
                with toutes_les_commandes.les_commandes[i] do begin
                        if  (le_client.num_tel ='1') or (le_client.num_tel ='2') then begin
                                ca_emporter.montant := ca_emporter.montant + prix_total;
                                inc(ca_emporter.nb_commandes)
                                end else begin
                                ca_livraison.montant := ca_livraison.montant + prix_total;
                                inc(ca_livraison.nb_commandes)
                        end{if};

                end{with};
        end{for};
        chiffre_daffaire_ttc := ca_emporter.montant + ca_livraison.montant;
        chiffre_daffaire_ht := chiffre_daffaire_ttc - (chiffre_daffaire_ttc*tva);
        gotoxy(45,17);write(ca_emporter.nb_commandes);
        gotoxy(58,17);write(ca_emporter.montant:0:2);
        gotoxy(45,22);write(ca_livraison.nb_commandes);
        gotoxy(58,22);write(ca_livraison.montant:0:2);
        gotoxy(52,35);write(chiffre_daffaire_ht:0:2);
        gotoxy(52,39);write(chiffre_daffaire_ttc:0:2);

        labas:

        gotoxy(30,47);write('1-Journal  2-Menu');
        reponse := readkey;
        case upcase(reponse) of
                '1','J',#13 : goto ici;
                '2','M'     : menu;
                else goto labas;
        end{case};

end{journal};

procedure efface_ecran;
var
        j : byte;
begin

        for j:= 0 to 80 do begin
                gotoxy(0,j);writeln('                                                                                 ');
                gotoxy(1,1);
        end {for};
end{efface_ecran};

procedure fiche_vide(num_commande : smallint);

begin

        un_rectangle(5,5,70,20);
        un_rectangle(5,20,70,41);
        un_rectangle(5,41,70,45);
        un_rectangle(5,20,15,41);
        un_rectangle(25,20,55,41);
        un_rectangle(57,42,68,44);
        un_rectangle(5,18,70,20);
        un_rectangle(5,18,15,20 );
        un_rectangle(25,18,55,20);
        gotoXY(20,3);write ('S A I S I E    D E   C O M M A N D E');
        gotoXY(6,6);write ('CODE VENDEUR  :');
        gotoXY(45,6);write('NUM COMMANDE: ');
        gotoXY(60,6);write(num_commande);
        gotoXY(6,8);write ('NUM TEL       :');
        gotoXY(45,8);write('NOM CLIENT  : ');
        gotoXY(6,10);write('ADRESSE CLIENT:');
        gotoXY(28,16);write('C O M M A N D E');
        gotoXY(6,19);write('Code Prod');
        gotoXY(17,19);write('Quantite') ;
        gotoXY(34,19);write('Nom Produit');
        gotoXY(60,19);write('Prix');
        gotoXY(45,43);write('PRIX TOTAL');

        gotoXY(5,18);write(#204);
        gotoXY(5,20);write(#204);
        gotoXY(5,41);write(#204);
        gotoXY(70,18);write(#185);
        gotoXY(70,20);write(#185);
        gotoXY(70,41);write(#185);
        gotoXY(15,18);write(#203);
        gotoXY(25,18);write(#203);
        gotoXY(55,18);write(#203);
        gotoXY(15,20);write(#206);
        gotoXY(25,20);write(#206);
        gotoXY(55,20);write(#206);
        gotoXY(15,41);write(#202);
        gotoXY(25,41);write(#202);
        gotoXY(55,41);write(#202);

end {fiche_vide};

procedure fiche_vide0;

begin

        un_rectangle(5,5,70,20);
        un_rectangle(5,20,70,41);
        un_rectangle(5,41,70,45);
        un_rectangle(5,20,15,41);
        un_rectangle(25,20,55,41);
        un_rectangle(57,42,68,44);
        un_rectangle(5,18,70,20);
        un_rectangle(5,18,15,20 );
        un_rectangle(25,18,55,20);
        gotoXY(6,6);write ('CODE VENDEUR  :');
        gotoXY(45,6);write('NUM COMMANDE: ');
        gotoXY(6,8);write ('NUM TEL       :');
        gotoXY(45,8);write('NOM CLIENT  : ');
        gotoXY(6,10);write('ADRESSE CLIENT:');
        gotoXY(28,16);write('C O M M A N D E');
        gotoXY(6,19);write('Code Prod');
        gotoXY(17,19);write('Quantite') ;
        gotoXY(34,19);write('Nom Produit');
        gotoXY(60,19);write('Prix');
        gotoXY(45,43);write('PRIX TOTAL');

        gotoXY(5,18);write(#204);
        gotoXY(5,20);write(#204);
        gotoXY(5,41);write(#204);
        gotoXY(70,18);write(#185);
        gotoXY(70,20);write(#185);
        gotoXY(70,41);write(#185);
        gotoXY(15,18);write(#203);
        gotoXY(25,18);write(#203);
        gotoXY(55,18);write(#203);
        gotoXY(15,20);write(#206);
        gotoXY(25,20);write(#206);
        gotoXY(55,20);write(#206);
        gotoXY(15,41);write(#202);
        gotoXY(25,41);write(#202);
        gotoXY(55,41);write(#202);

end {fiche_vide};

procedure fiche_encaissement;
begin
        efface_ecran;
        un_rectangle(5,18,70,60);
        un_rectangle(5,20,79,57);
        un_rectangle(12,18,24,57);
        un_rectangle(35,18,60,57);
        un_rectangle(60,57,70,60);
        un_rectangle(70,18,79,60);
        //gotoxy(2,10);write('DATE : ',datetostr(date));
        //gotoxy(45,10);write('HEURE : ',timetostr(time));
        gotoXY(12,16);write('E N C A I S S E M E N T    V E N D E U R');
        gotoXY(6,19);write('NumCom');
        gotoXY(15,19);write('Numtel') ;
        gotoXY(25,19);write('NomClient');
        gotoXY(40,19);write('Adresse Client');
        gotoXY(63,19);write('Prix');
        gotoXY(72,19);write('Heure');

end{fiche_encaissement} ;

function est_valable(const s : string): boolean;
var

   ss : string;
const intervalle =[48..57];

begin
  ss:=s;
  if (ss='') then est_valable:=true
   else if not(integer(ss[length(ss)]) in intervalle) then
        est_valable:=false

  else begin
        delete(ss,length(ss),length(ss)+1);
        est_valable:=est_valable(ss);
  end{if};

end{est_valable};

procedure afficher_prix(out piz : T_pizza; i: byte);

var     qte     : string[3] ;
        pizza   : T_pizza;

begin

        assign(objet_produit,file_produit);
        reset(objet_produit);
        while not (eof(objet_produit)) do begin
                read(objet_produit,pizza);
                if  piz.code = pizza.code then begin
                        repeat
                        a_faire('Entrer la quantite');
                        gotoxy(19,20+i);write('    ');
                        gotoxy(19,20+i);readln(qte);
                        until  est_valable(qte);
                        if qte='' then begin
                         piz.quantite:=1;
                         gotoxy(19,20+i);write(1);

                         end else piz.quantite:=strtoint(qte);
                        gotoxy(35,20+i);write(pizza.libelle);
                        gotoxy(61,20+i);write(pizza.prix:0:2);
                        piz.prix:=pizza.prix;
                        piz.libelle:=pizza.libelle;

                end{if};

        end{while};
        close(objet_produit);

end {afficher_prix};

procedure a_faire(phrase : string);
begin
  gotoXY(6,47);write('                                                                              ');
  gotoXY(6,47);write(phrase);
end{a_faire};

procedure saisir_commande(out comm : T_commande);
label
        ici,labas,la;
var
        reponse         : char;
        last_commande   : cardinal;
        n               : integer;
        les_commandes   : T_les_commandes;
        procedure saisir_client(out le_client : T_client);
        begin

                le_client.nb_cmd_effectuer:=1;
                repeat
                        a_faire('Entrer le nom du client');
                        gotoxy(60,8);readln(le_client.nom);
                until (le_client.nom<>'');
                repeat
                        a_faire('Entrer l''adresse du client');
                        gotoxy(21,10);readln(le_client.adresse);
                until le_client.adresse<>'';
        end{saisir_client};

        procedure afficher_client(numero_tel: string);
        var
                client : T_client;
        begin
                client := lire_un_client(numero_tel);
                inc(client.nb_cmd_effectuer);
                gotoxy(60,8);write(client.nom);
                gotoxy(21,10);write(client.adresse);
                modifier_nb_cmd_effectue(numero_tel,client.nb_cmd_effectuer);
                if ((numero_tel<>'1') and (numero_tel<>'2')) then begin
                        gotoxy(10,16);
                        write(client.nom,' a commande ',client.nb_cmd_effectuer,' fois chez nous !!');
                end{if};
                comm.le_client:=client;

        end{afficher_client};

begin
        ici:last_commande := nb_total_commande(file_commande);
        les_commandes :=lire_les_commandes_du_jour(datetostr(date));
        n:=les_commandes.nb_commande;
        efface_ecran;
        fiche_vide(n);
        gotoXY(60,6);write(n,'-00',last_commande);
        //fiche_vide(last_commande);
        gotoXY(6,12);write ('DATE :');write(datetostr(date));
        gotoXY(50,12);write ('HEURE :');;write(timetostr(time));
        with comm do begin
                repeat
                        a_faire('Entrer le code du Vendeur');
                        gotoxy(21,6);readln(code_vendeur);
                        if (code_vendeur=('q')) or (code_vendeur=('Q'))  then
                           BEGIN
                              sous_menuS;
                              exit   ;
                           end;
                until code_vendeur<>'';

                repeat
                        a_faire('Entrer le numero de telephone du client');
                        gotoxy(21,8);readln(le_client.num_tel);
                        if (le_client.num_tel=('q')) or (le_client.num_tel=('Q'))  then
                           begin
                              sous_menuS;
                              exit;
                           end;
                until le_client.num_tel<>'';
                with le_client do begin
                        if not(est_client(num_tel)) then begin
                                saisir_client(le_client)
                                end else begin
                                afficher_client(num_tel);
                        end{if};
                        commande_client.nb_de_pizza:=1;
                        prix_total:=0;
                        la:
                        a_faire('Entrer le code du produit ou ''V'' pour Valider ''Q'' pour Quitter');
                        gotoxy(7,20+commande_client.nb_de_pizza);
                        readln(commande_client.les_pizzas[commande_client.nb_de_pizza].code);
                        if (commande_client.les_pizzas[commande_client.nb_de_pizza].code=('q'))
                         or (commande_client.les_pizzas[commande_client.nb_de_pizza].code=('Q'))
                         then
                           begin
                              sous_menuS;
                              exit;
                           end;
                        while (commande_client.les_pizzas[commande_client.nb_de_pizza].code<>'V') or (commande_client.nb_de_pizza=nb_max_pizza) do begin
                                if not est_pizza(commande_client.les_pizzas[commande_client.nb_de_pizza].code) then begin
                                        gotoxy(7,20+commande_client.nb_de_pizza);
                                        write('     ');
                                        gotoxy(7,20+commande_client.nb_de_pizza);
                                        goto la;
                                        end else begin
                                        afficher_prix(commande_client.les_pizzas[commande_client.nb_de_pizza],commande_client.nb_de_pizza);
                                        prix_total := prix_total +
                                        (commande_client.les_pizzas[commande_client.nb_de_pizza].prix *
                                        commande_client.les_pizzas[commande_client.nb_de_pizza].quantite);
                                        inc(commande_client.nb_de_pizza);
                                        gotoxy(60,43);writeln(prix_total:0:2);
                                        a_faire('Entrer le code du produit ou ''V'' pour Valider ''Q'' pour Quitter');
                                        gotoxy(7,20+commande_client.nb_de_pizza);
                                        readln(commande_client.les_pizzas[commande_client.nb_de_pizza].code);
                                end{if};
                        end{while};
                end {with le_client};
                date_commande:=datetostr(date);
                heure_commande:=(time);
                ecrir_fichier(comm);
                if not(est_client(le_client.num_tel)) then begin
                        ajouter_client(le_client);
                end{if};
                labas:
                a_faire('1-Creer   2-Modifier   3-Annuler  4-Precedente   5-Suivante  6-mEnu');
                reponse := readkey;
                case upcase(reponse) of
                        '1','C',#13 : goto ici;
                        '2','M' : modifier_commande(last_commande);
                        '3','A' : annuler_commande(last_commande);
                        '4','P' : commande_precedente(last_commande);
                        '5','S' : commande_suivante(last_commande);
                        '6','E' : menu;
                        else goto labas;
                end{case};
        end{with};

end{saisir_commande};

procedure afficher_commande(num_cmd: cardinal);

VAR     i       : byte;
        n : integer;
        commande:T_commande;
begin
        efface_ecran;
        n:=nb_total_commande(file_commande);
        commande:=lire_une_commande(num_cmd);
        fiche_vide(num_cmd);
        gotoXY(6,12);write ('DATE :');write(Commande.date_commande);
        gotoXY(50,12);write ('HEURE :');;write(timetostr(commande.heure_commande));
        gotoXY(65,6);WRITE('/',n-1);
        with commande do begin
                gotoxy(21,6);write(code_vendeur);
                with le_client do begin
                        gotoxy(21,8);write(num_tel);
                        gotoxy(60,8);write(nom);
                        gotoxy(21,10);write(adresse);
                         for i := 1 to commande_client.nb_de_pizza-1 do begin
                                gotoxy(7,20+i);
                                write(commande_client.les_pizzas[i].code);
                                gotoxy(19,20+i);
                                write(commande_client.les_pizzas[i].quantite);
                                gotoxy(35,20+i);
                                write(commande_client.les_pizzas[i].libelle);
                                gotoxy(61,20+i);
                                write(commande_client.les_pizzas[i].prix:0:2);
                                gotoxy( 60,43);writeln(prix_total:0:2);

                        end{for};
                end {with le_client};
        end{with commande};

end{afficher_commande};

procedure sous_menuR;
var rep : char;
label labas;

begin
labas:
        a_faire('1-Recherche 2-          3-         4-            5-         6-mEnu');
        rep := readkey;
        case upcase(rep) of
                '1','R',#13 : rechercher_commande;
                '6','E' : menu;
                else goto labas;
        end;
end{sous_menu};
procedure sous_menuS;
var rep : char;
label labas;

begin
labas:
        a_faire('1-Creer     2-          3-         4-            5-         6-mEnu');
        rep := readkey;
        case upcase(rep) of
                '1','C',#13 : saisir_commande(com);
                '6','E' : menu;
                else goto labas;
        end;
end{sous_menuS};

procedure rechercher_commande;
var
        num,n   : cardinal;
        reponse : char;
        numero  : string;
label ici, labas;
begin

        ici: efface_ecran;
        n:=nb_total_commande(file_commande);
        fiche_vide0;
        repeat
        gotoXY(60,6);write('          ');
        gotoXY(60,6);readln(numero);
        if (numero=('q')) or (numero=('Q'))  then
                           BEGIN
                              sous_menuR;
                              exit   ;
                           end;
        until est_valable(numero);
        charger(50,10,13);
        if numero='' then
                num:=1
                else
                num:=strtoint(numero);
        if (num < n) AND (num>0) then begin
                afficher_commande(num);

                end else begin
                gotoxy(10,12);write('                                           ');
                gotoxy(10,13);write('                                           ');
                gotoxy(10,14);write('                                           ');
                gotoxy(10,15);write('                                           ');
                gotoxy(10,13);write('Ce numero de commande n''existe pas  !!!');
                BEGIN
                    sous_menuR;
                    exit;
                end;
        end {if};
        labas:
        a_faire('1-Recherche 2-Modifier  3-Annuler  4-Precedente  5-Suivante 6-mEnu');
        reponse := readkey;
        case upcase(reponse) of
                '1','R',#13 : goto ici;
                '2','M' : modifier_commande(num);
                '3','A' : annuler_commande(num);
                '4','P' : commande_precedente(num);
                '5','S' : commande_suivante(num);
                '6','E' : menu;
                else goto labas;
        end;

end {rechercher_commande};

procedure recherche_par_date;
type recherche = record
         date : string;
         debut:integer;
         fin  :integer;
      end{record};
type T_recherche = array of recherche;
var  commande : T_commande;
  search : recherche;
  tab_rech: T_recherche;
  i,j : integer;

begin
  i:=0;
  j:=0;
  assign(objet,file_commande);
  reset(objet);
  if filesize(objet)<>0 then
  begin
  seek(objet,0);
  read(objet,commande);
  search.date:=commande.date_commande;
  search.debut:=i+1;
  while not eof(objet) do begin

    if commande.date_commande=search.date then begin
      read(objet,commande);
      inc(i);
   end else begin
      search.fin:=i;
      setlength(tab_rech,j+1);
      tab_rech[high(tab_rech)]:=search;
      inc(i);
      inc(j);
      search.debut:=i;
      read(objet,commande);
      search.date:=commande.date_commande;
    end;
  end{while};
  close(objet);
  end;
  for j:=low(tab_rech) to high(tab_rech) do begin
  if (j+1) mod 10 = 0 then
      begin
       write('Appuyer sur Enter pour voir la suite....');
       readln;
  end{if};
  with tab_rech[j] do begin
   writeln('Pour la date du ',date,' les commandes sont comprises entre');
   writeln('le N° ',debut,' et N° ',fin);
   writeln;
   writeln('-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+');
  End {with};

  end{for};

end{recherche_par_date};

procedure menu ;
var
        choix : char;
label ici;
begin
        ici:
        efface_ecran;
        un_rectangle(1,1,50,27);
        un_rectangle(1,1,50,7);
        gotoxy(1,7);write(#204);
        gotoxy(50,7);write(#185);
        gotoxy(22,4);write('M E N U');
        gotoxy(2,2);write('DATE : ',datetostr(date));
        gotoxy(34,2);write('HEURE : ',timetostr(time));
        gotoxy(3,9);write('1 - (S)AISIR COMMANDE');
        gotoxy(3,11);write('2 - (R)ECHERCHER UNE COMMANDE');
        gotoxy(3,13);write('3 - (D)ECAISSER VENDEUR');
        gotoxy(3,15);write('4 - (J)OURNAL');
        gotoxy(3,17);write('5 - (I)NITIALISATION FICHIER');
        gotoxy(3,19);write('6 - (C)REER PRODUIT');
        gotoxy(3,21);write('7 - (P)IZZAS A FAIRE');
        gotoxy(3,23);write('8 - (Q)UITTER');
        gotoxy(10,26);write('VOTRE CHOIX ? [1,2,3,4,5,6,7,8]');
        choix := readkey;
        case upcase(choix) of
                '1','S',#13 : saisir_commande(com);
                '2','R' : rechercher_commande ;
                '3','D' : decaisser_vendeur;
                '4','J' : journal;
                '5','I' : initialisation;
                '6','C' : ajouter_produit;
                '7','P' : pizza_a_faire;
                '8','Q' : exit;
                else
                begin
                        efface_ecran;
                        gotoxy(5,21);write('Choisir entre [1,2,3,4,5,6,7,8] !');
                        sleep(2000);
                        goto ici;
                end;
        end;{case}
end {menu};

procedure decaisser_vendeur;

var     i,j             : byte;
        montant_du      : real;
        reponse         : char;
        com             : T_les_commandes;
        num             : string[4];
label ici, labas;
begin
        com := lire_les_commandes_du_jour(datetostr(date));
        ici: efface_ecran;
        fiche_encaissement;
        j:=0;
        montant_du :=0;
        gotoXY(22,13);write('Entrer le code du vendeur : ');
        repeat
                gotoXY(50,13);readln(num);
        until num<>'';
        for i:=0 to com.nb_commande do begin
                if num = com.les_commandes[i].code_vendeur then begin
                        gotoxy(8,21+j);write(i);
                        gotoxy(13,21+j);write(com.les_commandes[i].le_client.num_tel);
                        gotoxy(26,21+j);write(com.les_commandes[i].le_client.nom);
                        gotoxy(36,21+j);write(com.les_commandes[i].le_client.adresse);
                        gotoxy(62,21+j);write(com.les_commandes[i].prix_total:0:2);
                        gotoXY(71,21+j);write(TIMEtostr(com.les_commandes[i].heure_commande));
                        montant_du:=montant_du+com.les_commandes[i].prix_total;
                        inc(j);
                end{if};

        end {for};
        gotoXY(12,58);write('Montant total encaisse  par le vendeur ',num,' est : ');
        gotoXY(62,58);write(montant_du:0:2);
        labas:
        gotoxy(30,61);write('1-Decaisser 2-Menu');
        reponse := readkey;
        case upcase(reponse) of
                '1','D',#13 : goto ici;
                '2','M'     : menu;
                else goto labas;
        end{case};

end{decaisser_vendeurs};
procedure pizza_a_faire;
VAR
        t       : T_les_commandes;
        i,j,k   : integer;
begin
        repeat
                k:=0;
                efface_ecran;
                un_rectangle(5,18,50,60);
                un_rectangle(5,20,50,60);
                un_rectangle(12,18,24,60);
                un_rectangle(35,18,50,60);
                gotoXY(6,19);write('Qte');
                gotoXY(15,19);write('Code') ;
                gotoXY(25,19);write('Num Commande');
                gotoXY(40,19);write('Duree');
                t:=lire_les_commandes_du_jour(datetostr(date));
                for j:=0 to t.nb_commande do begin
                        for i:=1 to t.les_commandes[j].le_client.commande_client.nb_de_pizza-1 do begin
                                t := lire_les_commandes_du_jour(datetostr(date));
                                gotoXY(8,21+k);write(t.les_commandes[j].le_client.commande_client.les_pizzas[i].quantite);
                                gotoXY(17,21+k);write(t.les_commandes[j].le_client.commande_client.les_pizzas[i].code);
                                gotoXY(38,21+k);write(timetostr(time-t.les_commandes[j].heure_commande));
                                inc(k);
                        end{for};

                end{for};
                gotoXY(50,60);write('1-Actualiser  2-Menu');

        until (readkey='M') OR (readkey='m') OR (readkey='2');
        menu;

end{pizza_a_faire};

end.

Conclusion :


merci à Mina Diarra qui m'a aidé à créer ce logiciel.

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.