source: pmb4.2/trunk/fuentes/pmb/classes/nomenclature/nomenclature_nomenclature.class.php @ 815

Last change on this file since 815 was 815, checked in by jrpelegrina, 4 years ago

Initial release of pmb 4.2

  • Property svn:executable set to *
File size: 18.3 KB
Line 
1<?php
2// +-------------------------------------------------+
3// © 2002-2014 PMB Services / www.sigb.net pmb@sigb.net et contributeurs (voir www.sigb.net)
4// +-------------------------------------------------+
5// $Id: nomenclature_nomenclature.class.php,v 1.17 2015-04-03 11:16:23 jpermanne Exp $
6
7if (stristr($_SERVER['REQUEST_URI'], ".class.php")) die("no access");
8
9//require_once($class_path."/nomenclature/nomenclature_family.class.php");
10
11
12/**
13 * class nomenclature_nomenclature
14 * Représente une nomenclature
15 */
16class nomenclature_nomenclature {
17
18        /** Aggregations: */
19
20        /** Compositions: */
21
22         /*** Attributes: ***/
23
24        /**
25         * Tableau des familles de la nomenclature
26         * @access protected
27         */
28        protected $families;
29
30        /**
31         * Nomenclature abrégée
32         * @access protected
33         */
34        protected $abbreviation;
35       
36        /**
37         * Tableau des ateliers de la nomenclature
38         * @access protected
39         */
40        protected $workshops;
41               
42        protected $family_definition_in_progress = false;
43        protected $musicstand_definition_in_progress = false;
44        protected $instrument_definition_in_progress = false;
45        protected $other_instrument_definition_in_progress = false;
46        protected $current_family= -1;
47        protected $current_musicstand=0;
48        protected $musicstand_effective = 1;
49        protected $instrument;
50        protected $other_instrument;
51        protected $musicstand_part=0;
52        protected $indefinite_character = "~";
53        /**
54         * Constructeur
55         *
56         * @return void
57         * @access public
58         */
59        public function __construct( ) {
60                $this->init_default_families_definition();
61                $this->init_default_workshops_definition();
62        } // end of member function __construct
63
64       
65        protected function init_default_families_definition(){
66                global $dbh;
67                $query = "select id_family from nomenclature_families order by family_order asc";
68                $result = pmb_mysql_query($query,$dbh);
69                $this->families = array();
70                if(pmb_mysql_num_rows($result)){
71                        while($row = pmb_mysql_fetch_object($result)){
72                                $this->families[] = new nomenclature_family($row->id_family);
73                        }
74                }
75        }
76       
77        protected function init_default_workshops_definition(){
78                global $dbh;
79                $query = "select id_workshop from nomenclature_workshops order by workshop_order asc";
80                $result = pmb_mysql_query($query,$dbh);
81                $this->workshops = array();
82                if($result){
83                        if(pmb_mysql_num_rows($result)){
84                                while($row = pmb_mysql_fetch_object($result)){
85                                        $this->workshops[] = new nomenclature_workshop($row->id_workshop);
86                                }
87                        }       
88                }
89               
90        }
91        /**
92         * Setter
93         *
94         * @param string abbreviation Nomenclature abrégée
95
96         * @return void
97         * @access public
98         */
99        public function set_abbreviation( $abbreviation ) {
100                $this->abbreviation = pmb_preg_replace('/\s+/', '', $abbreviation);
101        } // end of member function set_abbreviation
102
103        /**
104         * Getter
105         *
106         * @return string
107         * @access public
108         */
109        public function get_abbreviation( ) {
110                return  pmb_preg_replace('/\s+/', '', $this->abbreviation);
111        } // end of member function get_abbreviation
112
113        /**
114         * Getter
115         *
116         * @return nomenclature_family
117         * @access public
118         */
119        public function get_families( ) {
120                return $this->families;
121        } // end of member function get_families
122
123        /**
124         * Setter
125         *
126         * @param nomenclature_family families Tableau des familles
127
128         * @return void
129         * @access public
130         */
131        public function set_families( $families ) {
132                $this->families = $families;
133        } // end of member function set_families
134
135        /**
136         * Analyse la nomenclature abrégée pour setter la property families
137         *
138         * Appel à  la machine d'états
139         *
140         * @param bool partial Booléen qui m'indique que la nomenclature n'est pas complète
141
142         * @return void
143         * @access public
144         */
145       
146        public function get_next_family(){
147                if(count($this->families) > $this->current_family){
148                        $this->family_definition_in_progress = true;
149                        $this->current_family++;
150                        $this->current_musicstand = -1;
151                        return true;
152                }else{
153                        $this->family_definition_in_progress = false;
154                }
155                return false;
156        }
157       
158        public function get_next_musicstand(){
159                $this->musicstand_part=0;
160                if(count($this->families[$this->current_family]->get_musicstands()) > $this->current_musicstand) {
161                        $this->musicstand_definition_in_progress = true;
162                        $this->musicstand_effective=1;
163                        $this->current_musicstand++;
164                        return true;
165                }else {
166                        $this->musicstand_definition_in_progress = false;
167                        return false;
168                }
169        }
170       
171        public function get_standard_instrument(){
172                if(!$this->instrument_definition_in_progress){
173                        $this->instrument_definition_in_progress = true;
174                        return clone $this->families[$this->current_family]->get_musicstand($this->current_musicstand)->get_standard_instrument();
175                }
176        }
177       
178        public function get_no_standard_instrument(){
179                if(!$this->instrument_definition_in_progress){
180                        $this->instrument_definition_in_progress = true;
181                        $no_std_inst = new nomenclature_instrument(0,"", "");
182                        $no_std_inst->set_standard(false);
183                        return $no_std_inst; 
184                }
185        }
186       
187        public function get_other_instrument(){
188                if(!$this->other_instrument_definition_in_progress){
189                        $this->other_instrument_definition_in_progress = true;
190                        $no_std_inst = new nomenclature_instrument(0,"", "");
191                        $no_std_inst->set_standard(false);
192                        return $no_std_inst;
193                }
194        }
195
196        protected function finalize_current_other_instrument(){
197                if($this->other_instrument_definition_in_progress){
198                        $this->instrument->add_other_instrument($this->other_instrument);
199                        $this->other_instrument = null;
200                        $this->other_instrument_definition_in_progress = false;
201                }
202        }
203       
204        protected function finalize_current_instrument(){
205                if($this->instrument_definition_in_progress){
206                        $this->finalize_current_other_instrument();
207                        $this->families[$this->current_family]->get_musicstand($this->current_musicstand)->add_instrument($this->instrument,true);
208//                      var_dump("Famille ".$this->current_family." (". $this->families[$this->current_family]->get_name().
209//                      ") => Pupitre ".$this->current_musicstand." (".
210//                      $this->families[$this->current_family]->get_musicstand($this->current_musicstand)->get_name().
211//                      ") => ".
212//                      count($this->families[$this->current_family]->get_musicstand($this->current_musicstand)->get_instruments()));
213//                      var_dump($this->families[$this->current_family]->get_musicstand($this->current_musicstand));
214                        $this->instrument = null;
215                        $this->instrument_definition_in_progress = false;
216                }else if($this->musicstand_effective > 0){
217                        //cas ou seul l'effectif est défini, on prend alors l'instrument standard avec l'effectif correspondant
218                        $this->instrument = clone $this->families[$this->current_family]->get_musicstand($this->current_musicstand)->get_standard_instrument();
219                        $this->instrument->set_effective($this->musicstand_effective);
220                        $this->instrument_definition_in_progress = true;
221                        $this->finalize_current_instrument();
222                }
223        }
224       
225        protected function finalize_current_musicstand(){
226                if($this->musicstand_definition_in_progress){
227                        $this->finalize_current_instrument();
228                        $this->families[$this->current_family]->get_musicstand($this->current_musicstand)->set_effective($this->musicstand_effective);
229                        //réinitialisation
230                        $this->musicstand_effective=1;
231                        $this->musicstand_definition_in_progress = false;
232                }
233        }
234       
235        protected function finalize_current_family(){
236                $this->finalize_current_musicstand();
237                //réinitialisation
238                $this->family_definition_in_progress = false;
239        }
240               
241        public function analyze(){
242                global $msg;
243                $this->family_definition_in_progress = $this->musicstand_definition_in_progress = $this->instrument_definition_in_progress = $this->other_instrument_definition_in_progress = false;
244                $state = "START";
245                for($i=0 ; $i<strlen($this->abbreviation) ;$i++){
246                        $c = $this->abbreviation[$i];
247//                      var_dump($state."       => ".$c);
248                        switch($state){
249                                case "START" :
250                                case "NEW_FAMILY" :
251                                        //on veut un chiffre au départ...
252                                        if($c === "0"  || $c*1 > 0 ){
253                                                //si une famille est encore en cours de définition, il y a un problème
254                                                if($this->family_definition_in_progress){
255                                                        $state = "ERROR";
256                                                        $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_already_family_def"]);
257                                                }else{
258                                                        //on récupère la prochaine famille
259                                                        if(!$this->get_next_family()){
260                                                                //si plus de familles à définir, il y a un problème
261                                                                $state = "ERROR";
262                                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_end_family_def"]);
263                                                        }else{
264                                                                //on créé de le premier pupitre de la famille...
265                                                                if($this->musicstand_definition_in_progress){
266                                                                        $state = "ERROR";
267                                                                        $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_already_musicstand_def"]);
268                                                                }else{
269                                                                        if(!$this->get_next_musicstand()){
270                                                                                $state = "ERROR";
271                                                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_end_musicstand_def"]);
272                                                                        }else{
273                                                                                $this->musicstand_effective = $c;
274                                                                                $state = "MUSICSTAND";
275                                                                        }
276                                                                }
277                                                        }
278                                                }
279                                        }else{
280                                                $state = "ERROR";
281                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_no_numeric"]);
282                                        }
283                                        break;
284                                case "MUSICSTAND" :
285                                        //pas de pupitre en cours de définition, on a un problème
286                                        if(!$this->musicstand_definition_in_progress){
287                                                $state = "ERROR";
288                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_no_musicstand_def"]);
289                                        }else{
290                                                //ca peut être un chiffre encore (concaténation de l'effectif)
291                                                if($c === "0"  || $c*1 > 0 ){
292                                                        $this->musicstand_effective.= $c;
293                                                }else{
294                                                        switch($c){
295                                                                //fin de la famille
296                                                                case "-" :
297                                                                        $this->finalize_current_family();
298                                                                        $state="NEW_FAMILY";
299                                                                        break;
300                                                                //fin de pupitre
301                                                                case "." :
302                                                                        $this->finalize_current_musicstand();
303                                                                        $state = "NEW_MUSICSTAND";
304                                                                        break;
305                                                                case "[" :
306                                                                        $state = "NEW_INSTRUMENT";
307                                                                        break;
308                                                                case "]" :
309                                                                        $state = "ERROR";
310                                                                        $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_no_detail_musicstand_def"]);
311                                                                        break;
312                                                        }
313                                                }
314                                        }
315                                        break;
316                                case "NEW_MUSICSTAND" :
317                                        // pupitre en cours de définition, on a un problème
318                                        if($this->musicstand_definition_in_progress){
319                                                $state = "ERROR";
320                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_already_musicstand_def"]);
321                                        }else{
322                                                if($c === "0"  || $c*1 > 0 ){
323                                                        if(!$this->get_next_musicstand()){
324                                                                $state = "ERROR";
325                                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_end_musicstand_def"]);
326                                                        }else{
327                                                                $this->musicstand_effective = $c;
328                                                                $state = "MUSICSTAND";
329                                                                $this->musicstand_part=0;
330                                                        }
331                                                }else{
332                                                        $state = "ERROR";
333                                                        $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_no_numeric"]);
334                                                }
335                                        }
336                                        break;
337                                case "NEW_INSTRUMENT" :
338                                        // un instrument est déjà en cours de définition
339                                        if($this->instrument_definition_in_progress){
340                                                $state = "ERROR";
341                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_already_instrument_def"]);
342                                        }else{
343                                                // un chiffre ? alors c'est un instrument standard
344                                                if($c === "0"  || $c*1 > 0 ){                                                   
345                                                        if($this->families[$this->current_family]->get_musicstand($this->current_musicstand)->get_divisable()){
346                                                                $this->instrument->set_effective($c);
347                                                                $this->musicstand_part++;
348                                                                $this->instrument->set_part($this->musicstand_part);                                                           
349                                                        }else{
350                                                                //le chiffre est le numéro d'ordre sur le pupitre...
351                                                        }       
352                                                        $this->instrument = $this->get_standard_instrument();
353                                                        $state = "INSTRUMENT_STANDARD";
354                                                }else{
355                                                        switch($c){
356                                                                case "]" :
357                                                                case "." :
358                                                                case "-" :
359                                                                        $state = "ERROR";
360                                                                        $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze"]);
361                                                                        break;
362                                                                default :
363                                                                        $this->instrument = $this->get_no_standard_instrument();
364                                                                        $this->instrument->set_code($c);
365                                                                        $state = "INSTRUMENT_NO_STANDARD"; 
366                                                        }
367                                                }
368                                        }
369                                        break;
370                                case "INSTRUMENT_STANDARD" :
371                                        if(!$this->instrument_definition_in_progress){
372                                                $state = "ERROR";
373                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_no_instrument_def"]);
374                                        }else { 
375                                                if($c === "0"  || $c*1 > 0 ){
376                                                        if($this->families[$this->current_family]->get_musicstand($this->current_musicstand)->get_divisable()){
377                                                                $this->instrument->set_effective($this->instrument->get_effective().$c);
378                                                        }else{
379                                                                //rien à faire, c'est la suite du numéro d'ordre
380                                                        }
381                                                }else{
382                                                        switch($c){
383                                                                case "-" :
384                                                                        $state = "ERROR";
385                                                                        $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_close_musicstand_detail"]);
386                                                                break;
387                                                                case "." :
388                                                                        $this->finalize_current_instrument();
389                                                                        $state = "NEW_INSTRUMENT";
390                                                                        break;
391                                                                case "]" :
392                                                                        $state = "MUSICSTAND";
393                                                                        break;
394                                                                case "/" :
395                                                                        $state = "NEW_OTHER_INSTRUMENT";
396                                                                        break;
397                                                        }
398                                                }
399                                        }
400                                        break;
401                                case "INSTRUMENT_NO_STANDARD":
402                                        if(!$this->instrument_definition_in_progress){
403                                                $state = "ERROR";
404                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_no_instrument_def"]);
405                                        }else {
406                                                switch($c){
407                                                        case "-" :
408                                                                $state = "ERROR";
409                                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_close_musicstand_detail"]);
410                                                                break;
411                                                        case "." :
412                                                                $this->finalize_current_instrument();
413                                                                $state = "NEW_INSTRUMENT";
414                                                                break;
415                                                        case "]" :
416                                                                $state = "MUSICSTAND";
417                                                                break;
418                                                        case "/" :
419                                                                $state = "NEW_OTHER_INSTRUMENT";
420                                                                break;
421                                                        default : 
422                                                                $this->instrument->set_code($this->instrument->get_code().$c);
423                                                                break;
424                                                }
425                                        }
426                                        break;
427                                case "NEW_OTHER_INSTRUMENT" :
428                                        if($this->other_instrument_definition_in_progress){
429                                                $state = "ERROR";
430                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_already_other_instrument_def"]);
431                                        }else{
432                                                if($c === "0"  || $c*1 > 0 ){
433                                                        $state = "ERROR";
434                                                        $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_other_instrument_no_first_numeric"]);
435                                                }else{
436                                                        switch($c){
437                                                                case "/" :
438                                                                case "]" :
439                                                                case "." :
440                                                                case "-" :
441                                                                        $state = "ERROR";
442                                                                        $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze"]);
443                                                                        break;
444                                                                default :
445                                                                        $this->other_instrument = $this->get_other_instrument();
446                                                                        $this->other_instrument->set_code($this->other_instrument->get_code().$c);
447                                                                        $state = "OTHER_INSTRUMENT";
448                                                                        break;
449                                                        }
450                                                }
451                                        }
452                                        break;
453                                case "OTHER_INSTRUMENT" :
454                                        if(!$this->other_instrument_definition_in_progress){
455                                                $state = "ERROR";
456                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_no_other_instrument_def"]);
457                                        }else {
458                                                switch($c){
459                                                        case "-" :
460                                                                $state = "ERROR";
461                                                                $error = array('position'=> $i,'msg' => $msg["nomenclature_js_nomenclature_error_analyze_close_musicstand_detail"]);
462                                                                break;
463                                                        case "." :
464                                                                $this->finalize_current_instrument();
465                                                                $state = "NEW_INSTRUMENT";
466                                                                break;
467                                                        case "]" :
468                                                                $state = "MUSICSTAND";
469                                                                break;
470                                                        case "/" :
471                                                                $this->finalize_current_other_instrument();
472                                                                $state = "NEW_OTHER_INSTRUMENT";
473                                                                break;
474                                                        default :
475                                                                $this->other_instrument->set_code($this->other_instrument->get_code().$c);
476                                                                break;
477                                                }
478                                        }       
479                                        break;
480                                case "ERROR" :
481                                default:
482                                        continue;
483                                        break;
484                        }
485                }
486                if($state == "ERROR"){
487                        for($i=0 ; $i<strlen($this->abbreviation) ;$i++){
488                                if($error['position'] == $i){
489                                        print "<b>";
490                                }
491                                print $this->abbreviation[$i];
492                                if($error['position'] == $i){
493                                        print "</b>";
494                                }
495                        }
496                        var_dump($error['msg']);
497                }else{
498                        $this->finalize_current_family();
499                }
500        }
501       
502        /**
503         * Méthode qui vérifie la structure de l'arbre des familles
504         *
505         * @return bool
506         * @access public
507         */
508        public function check( ) {
509        } // end of member function check
510
511        /**
512         * Calcule et affecte la nomenclature abrégée à  partir de l'arbre
513         *
514         * @return void
515         * @access public
516         */
517        public function calc_abbreviation( ) {
518                $tfamilies = array();
519                foreach ($this->families as $family) {
520                        $nomenclature_family = new nomenclature_family($family->get_id());
521                        $nomenclature_family->calc_abbreviation();
522                        $tfamilies[] = $nomenclature_family->get_abbreviation();
523                }
524                $this->set_abbreviation(implode("-", $tfamilies));
525        } // end of member function calc_abbreviation
526       
527        public function get_families_tree(){
528                $tree = array();
529                foreach($this->families as $family){
530                        $tree[] = array(
531                                'id' => $family->get_id(),
532                                'name' => $family->get_name(),
533                                'musicstands' => $this->get_musiscstands_tree($family)                 
534                        );
535                }
536                return $tree;
537        }
538        protected function get_musiscstands_tree($family){
539                $tree = array();
540                foreach($family->get_musicstands() as $musicstand){
541                        $tree[] = $musicstand->get_tree_informations();
542                }
543                return $tree;
544        }
545       
546        public function get_indefinite_character(){
547                return $this->indefinite_character;
548        }
549       
550        public function set_indefinite_character($indefinite_charracter){
551                $this->indefinite_character = $indefinite_charracter;
552        }
553       
554        /**
555         * Getter
556         *
557         * @return nomenclature_workshop
558         * @access public
559         */
560        public function get_workshops( ) {
561                return $this->workshops;
562        } // end of member function get_workshops
563       
564        /**
565         * Setter
566         *
567         * @param nomenclature_workshop families Tableau des ateliers
568       
569         * @return void
570         * @access public
571         */
572        public function set_workshops( $workshops ) {
573                $this->workshops = $workshops;
574        } // end of member function set_workshops
575       
576        public function get_workshops_tree(){
577                $tree = array();
578                foreach($this->workshops as $workshop){
579                        $tree[] = array(
580                                        'id' => $workshop->get_id(),
581                                        'label' => $workshop->get_label(),
582                                        'instruments' => $this->get_instruments_tree($workshop)
583                        );
584                }
585                return $tree;
586        }
587       
588        protected function get_instruments_tree($workshop){
589                $tree = array();
590                foreach($workshop->get_instruments() as $instrument){
591                        $tree[] = $instrument->get_tree_informations();
592                }
593                return $tree;
594        }
595       
596} // end of nomenclature_nomenclature
Note: See TracBrowser for help on using the repository browser.