Vos meilleurs codes sources

**Laurpierre** · 08/02/2007, 13h50

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
<?php
/*
  string  md5 ( string   str , bool   raw_output )
  md5 calcule le MD5 de la chaîne de caractères str en utilisant
  l'algorithme RSA Data Security, Inc. MD5 Message-Digest Algorithm ,
  et retourne le résultat. Le résultat est un nombre de 32 caractères hexadécimaux.
  Note :Le paramètre raw_output a été ajouté en PHP 5.0.0 et vaut par défaut FALSE .

  string  base64_encode ( string   data )
  base64_encode retourne data encodé en base64.
  Cet encodage est fait pour permettre aux informations binaires d'être manipulées
  par les systèmes qui ne gèrent pas correctement les 8 bits,
  comme par exemple, les corps de mail.
  Une chaîne encodée base64 prend environs 33% de plus que les données initiales.

   Opérateur Dénomination Effet Syntaxe Résultat
   & ET bit-à-bit Retourne 1 si les deux bits de même poids sont à 1
                              9 & 12 (1001 & 1100)  => 8 (1000)
   | OU bit-à-bit Retourne 1 si l'un ou l'autre des deux bits de même poids est à 1 (ou les deux)
                              9 | 12 (1001 | 1100)  => 13 (1101)
   ^ OU exclusif Retourne 1 si l'un des deux bits de même poids est à 1 (mais pas les deux)
                              9 ^ 12 (1001 ^ 1100)  => 5 (0101)
   ~ Complément (NON) Retourne 1 si le bit est à 0 (et inversement)
                              ~9 (~1001)            => 6 (0110)

   srand() initialise le générateur de nombres aléatoires avec seed
   microtime() retourne le stimestamp Unix avec les microsecondes.

   rand($Min,$Max) Appelée sans les options $Min et $Max ,
   rand retourne un nombre pseudo-aléatoire entre 0 et RAND_MAX

*/
//-----------------------------------------------------------------
// $bEncrypt === TRUE  => cryptage
// $bEncrypt === FALSE => décryptage
function EnCrypt($Text,$Cle, $bEnCrypt = FALSE, $RandMin = 0, $RandMax = 64000)
{  $bCrypt = ($bEnCrypt === TRUE) ? FALSE : TRUE;
   while (TRUE)
   {  if ($bCrypt === TRUE)
      {  $KeyForCrypt = md5($Cle);
         $Text = ($bEnCrypt === FALSE)? base64_decode($Text) : $Text;
      }
      else
      {  srand((double)microtime()*1000000);
         $KeyForCrypt = md5(rand($RandMin,$RandMax));
      }
      for ($StrOut = "", $Cpt=0, $Pos=0; $Pos < strlen($Text); $Pos++, $Cpt++)
      {  $Cpt = ($Cpt == strlen($KeyForCrypt))? 0 : $Cpt;
         $StrOut .= ($bCrypt === FALSE)? substr($KeyForCrypt,$Cpt,1): "" ;
         $StrOut .= substr($Text,$Pos,1) ^ substr($KeyForCrypt,$Cpt,1);
      }
      if ($bCrypt === TRUE)
         break;
      $Text   = $StrOut;
      $bCrypt = TRUE;
   }
   if ($bEnCrypt === TRUE)
      return base64_encode($StrOut);
   for ($String = "", $Cpt = 0, $Pos = 1; $Pos <= strlen($StrOut); $Pos+=2, $Cpt+=2)
         $String.= (substr($StrOut,$Pos,1) ^ substr($StrOut,$Cpt,1) );
   return $String;
}
//-----------------------------------------------------------------
 
//Exemple de l'appel à la fonction EnCrypt:
$Cle = "Forum_des développeurs_PHP";
$Text = "Mon_adresse_email@Web.net";
$Crypt = EnCrypt($Text,$Cle,TRUE,0,1000);
$Decrypt = EnCrypt($Crypt,$Cle);
echo "\nTexte original [".strlen($Text)."]: $Text <Br>";
echo "\nCle [".strlen($Cle)."]: $Cle <Br>";
echo "\nTexte crypté[".strlen($Crypt)."] : $Crypt <Br>";
echo "\nTexte décrypté[".strlen($Decrypt)."] : $Decrypt <Br>";
$Crypt1 = EnCrypt($Text,$Cle,TRUE);
$Decrypt1 = EnCrypt($Crypt1,$Cle);
echo "\nTexte crypté[".strlen($Crypt1)."] : $Crypt1 <Br>";
echo "\nTexte décrypté[".strlen($Decrypt1)."] : $Decrypt1 <Br>";
?>

**christophetd** · 27/11/2009, 06h55

Bonjour,
Je vais bientôt vous proposer ma classe de gestion de formulaires, le temps que j'écrive la doc.
En attendant, voici un petit code (que j'utilise pour rédiger ma doc

) qui m'est très utile, et qui sert à colorer grâce à highlight_string les codes contenus dans les balises <code></code>.
Ça ne marche malheureusement que pour le code PHP.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
<?php
/* A mettre en fin de page. Pensez à mettre un ob_start() en début de script */
echo preg_replace_callback('#<code>(.+)</code>#isU', create_function('$matches', 'return "<div class=\"code\">".highlight_string("<?php\n".$matches[1], true)."</div>";'), 									ob_get_clean());

Exemple simple d'utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
<code>if($age < 18) {
    echo 'Bienvenue !';
}</code>

**hornetbzz** · 04/01/2010, 02h38

Petite fonction pour générer des barres graphiques avec un dégradé de couleur (rvb) et un texte dans la barre. Pratique pour afficher les résultats de sondage par exemple.

NOTA: Nécessite la librairie GD, images au format png

Exemple d'appel de la fonction depuis votre source php:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
$percent=60;
$text="salut";
$file_img='ben_ta_directory_img/ton_filename.png';
$img = CreateImageFade($base_x=550, $ratio_x=$percent, $base_y=25, $ratio_y=100, 
// color 1 for fading source
$red1=230, $green1=230, $blue1=255, 
// color 2 for fading target
$red2=0, $green2=0, $blue2=255,
// fade_direction=1 <=> horizontal fade, 2<=>vertical fade, 3<=>diag fade
$fade_direction=3,
$text, $offset_x= 40, $offset_y=20, $text_size=2, $file_img, $debug=false);
echo '<br/><img src="'. $img . '"/></br>';

Le code: rien de transcendant en soi mais c'est pratique et paramétrable

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
function CreateImageFade(
$base_x=550, $ratio_x=100, $base_y=25, $ratio_y=100, 	// bar length and height for 100% with a reduction ratio (for example, $percent result of the poll)
$red1, $green1, $blue1,									// color 1 for fading source
$red2, $green2, $blue2,									// color 2 for fading target
$fade_direction,										// 1 for horizontal fade (direction x), 1 for vertical fade (direction y), 1 for diagonal fade (direction xy)
$text, $text_offset_x, $text_offset_y, $text_size=2,	// text content and size/position parameters
$path_to_root_file_img, $debug=false) {					// image file (format png) to be saved as result
// -----------------------------------------------
	// File.extension
	$file_img_bar	= $path_to_root_file_img ;
 
	// Init: vérif des min/max des couleurs rvb et ratio
	$red1	= (($red1 <= 255) && ($red1 >= 0))?		$red1	: 255 ;
	$green1	= (($green1 <= 255) && ($green1 >= 0))?	$green1	: 255 ;
	$blue1	= (($blue1 <= 255) && ($blue1 >= 0))?	$blue1	: 255 ;
 
	$red2	= (($red2 <= 255) && ($red2 >= 0))?		$red2	: 23 ;
	$green2	= (($green2 <= 255) && ($green2 >= 0))?	$green2	: 23 ;
	$blue2	= (($blue2 <= 255) && ($blue2 >= 0))?	$blue2	: 230 ;
 
	$ratio_x = (($ratio_x > 0) && ($ratio_x <= 100))? $ratio_x : 5 ;
	$ratio_y = (($ratio_y > 0) && ($ratio_y <= 100))? $ratio_y : 5 ;
 
 
	$c1		= array('r' => $red1, 'v' => $green1, 'b' => $blue1);
	$c2		= array('r' => $red2, 'v' => $green2, 'b' => $blue2);
 
	$bar_x	= $ratio_x * $base_x / 100 ;
	$bar_y	= $ratio_y * $base_y / 100 ;
 
	 switch ($fade_direction)  {
		 case 1 : $t = $bar_x; 			break;
		 case 2 : $t = $bar_y;			break;
		 case 3 : $t = $bar_x + $bar_y; break;
		 default: $t = $bar_x; 			break;
	 }
 
	 // DEBUG
	 if ($debug) {
		echo "<br/>DEBUG: long_x = $bar_x, long_y = $bar_y";
	 }
 
	// Création de l'image
	$img	= imagecreatetruecolor($bar_x, $bar_y);
	$white	= imagecolorallocate($img, 255, 255, 255);		// couleur du fond
 
	// Dégradé : on dessine une ligne verticale, horizontale ou diagonale pour chaque pixel entre 0 et $t
	for ($i=0; $i < $t ; $i++)  {
 
		$r = $c1['r'] + $i * ($c2['r'] - $c1['r']) / $t;
		$v = $c1['v'] + $i * ($c2['v'] - $c1['v']) / $t;
		$b = $c1['b'] + $i * ($c2['b'] - $c1['b']) / $t;
 
		$c = imagecolorallocate($img, $r, $v, $b);
 
		switch ($fade_direction) {
			case 1 : imageline($img, $i, 0, $i, $bar_y, $c); break;
			case 2 : imageline($img, 0, $i, $bar_x, $i, $c); break;
			case 3 : imageline($img, max(0,($i-$bar_y)), min($i,$bar_y), min($i,$bar_x), max(0,($i-$bar_x)), $c); break;
		}
	}
 
	// Ajout du texte
	$white	= imagecolorallocate($img, 255, 255, 255);			// couleur du texte affiché sur l'image
	imagestring($img, $text_size,  $bar_x - $text_offset_x , $bar_y - $text_offset_y , $text , $white);
 
	 // Sauvegarde de l'image au format png
	 imagepng($img, $file_img_bar);
	 imagedestroy($img);
 
 return $file_img_bar;
 
} /* fin de CreateImageFade */

**gandahar1983** · 16/03/2011, 16h12

rafraichir l'image après upload, solution

Bonjour,
je découvre ce topic pour partager, c'est cool

j'ai été confronté pendant longtemps à ce problème de rechargement de l'image fraîchement envoyée au serveur... par exemple :

j'ai une galerie d'images qui ont un nom fixe(les images) genre image1.jpg, image2.jpg etc..
je remplace une image par une autre, mais le nom ne change pas
le navigateur affiche alors l'image en cache, on est obligé de cliquer sur F5 pour rafraîchir la page....

il y a quelques bidouillages sur la toile qui marchent assez bien mais dans mon cas, il y avait toujours un soucis !

au lieu de charger l'image avec la date ou un nombre aléatoire, la solution est de récupérer la poids de l'image (en bytes, assez précis) et de le placer juste après le nom du fichier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$la_photo='image.jpg';
$poids_foto='?'.filesize($la_photo);
echo '<img src='.$la_photo.$poids_foto.'>';

de cette façon, le moindre changement du poids force le rechargement
mais uniquement sur le fichier concerné, à l'inverse de rnd(1,9999) qui force toujours le rechargement...

si vous trouvez mieux, je suis preneur bien que cette bidouille soit très facile à mettre en place et ne nécessite pas énormément de modifs dans son code original...

voilà, c'est pas grand chose, mais ça marche

a+

**Maxoo** · 19/03/2011, 09h32

Envoyé par gandahar1983

[B][SIZE="6"]si vous trouvez mieux, je suis preneur bien que cette bidouille soit très facile à mettre en place et ne nécessite pas énormément de modifs dans son code original...

Envoyer des expires corrects, voir : http://julien-pauli.developpez.com/t...p/?page=page_8

**kichemans** · 27/12/2005, 10h47

desolé, je n'ai pas de FTP disponible pour mettre un lien vers un ZIP.

cette classe permet d'exploiter le webservice de cartographie michelin.

"l'api" fournie etant franchement super naze

, des fonctions avec 40 arguments a passer, des variables tableaux a 50dimensions, des resultats mis en session, des variables passées par réference ( et si le serveur est configuré pour ne pas accepter... )

j'ai donc fais ma classe ( qui se veut simple d'utilisation ) pour exploiter sans avoir 2000arguments a passer a chaque fonction...
( et aussi pour avoir quelque chose d'OO, parce-que ça deviens vite tres brouillon

)

REQUIERT :
-la classe NUSOAP
-le fichier de constantes michelin ( fournit sur le site ws.viamichelin.com)

Classe Adresse / AdresseList ( le constructeur de la classe michelinWebService prend en parametre le tableau generé par AdresseList->toArray())

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
class Adresse
{
var $adresse;
var $cp;
var $ville;
var $pays;
	function Adresse($adresse,$ville,$cp)
	{
	$this->adresse=$adresse;
	$this->ville=$ville;
	$this->cp=$cp;
	$this->pays='FRA';
	}
	function toArray()
	{
	return array('address' => $this->adresse, 'cityName' => $this->ville, 'postalCode' => $this->cp, 'stateName' => '', 'countryCode' =>$this->pays);
	}
}
 
class AdresseList
{
var $listeAddr;
var $nbAdresse;
var $position;
	function AdresseList(){
	$this->listeAddr=Array();
	$this->nbAdresse=0;
	}
	function getAdresse($i){
	return $this->listeAddr[$i];
	}
	function add($adresse)
	{
	$this->listeAddr[]=$adresse;
	$this->nbAdresse++;
	}
	function toArray()
	{
	$array=Array();
		for($i=0;$i<$this->nbAdresse;$i++)
		{
		$array[]=$this->listeAddr[$i]->toArray();
		}
	return $array;
	}
	function print_rd()
	{
	echo '<pre>';
	print_r($this->toArray());
	echo '</pre>';
	}
}

Classe michelinWebService

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
 
 
/////////////////////////////////////////////CLASS michelinWebService\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//
//
//
//**************************************************EXEMPLE D'UTILISATION*******************************************
//
////////////////////////////////////// --------------------------1 Affiche une carte des deux destinations )
/*
include_once("lib/michelinWS.class.php");
include_once("lib/ViaMichelinWS_CONST.php");
include_once("lib/config.php");
 
$listeAdresse=new AdresseList();
$adresse1=new Adresse('1place des hauts tillers','Gennevillier','92230');
$listeAdresse->add($adresse1);
$adresse2=new Adresse('Boulevard Charonne','Paris','75011');
$listeAdresse->add($adresse2);
 
$michelinWS=new michelinWebService(USERNAME,PASSWORD);
$michelinWS->setItineraryType(AVOID_TOLL_ROADS_ITINERARY);
$michelinWS->getLocationsList($listeAdresse->toArray());
$michelinWS->createItiSteps();
$t=$michelinWS->getRoute();
$t=$michelinWS->getMap();
header('Content-type image/gif');
echo $michelinWS->getMapBin();
*/
/////////////////////////////////////// ------------------------2 Affiche la distance de depart a arrivée )
/*
include_once("lib/michelinWS.class.php");
include_once("lib/ViaMichelinWS_CONST.php");
include_once("lib/config.php");
 
$listeAdresse=new AdresseList();
$adresse1=new Adresse('1place des hauts tillers','Gennevillier','92230');
$listeAdresse->add($adresse1);
$adresse2=new Adresse('Boulevard Charonne','Paris','75011');
$listeAdresse->add($adresse2);
 
$michelinWS=new michelinWebService(USERNAME,PASSWORD);
$michelinWS->setItineraryType(AVOID_TOLL_ROADS_ITINERARY);
$michelinWS->setDetailsLevel(SYNTHESIS_DETAIL_LEVEL);
$michelinWS->setResponseElements(ITINERARY_TRACE_ONLY);
$llist=$michelinWS->getLocationsList($listeAdresse->toArray());
$michelinWS->createItiSteps();
$t=$michelinWS->getRoute();
$dist=$michelinWS->getDistance();
print_r($dist);*/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class michelinWebService
{
var $login;
var $pass;
///////variable resultantes des appels de methodes soap
var $locationList;
var $itiSteps;
var $routeCalculationResult;
var $generateMapResult;
var $distResult;
var $bestMapResult;
///////Variable composant les requetes soap
var $responseOptions;
var $presentationOptions;
var $itineraryOptions;
//////variable composant $this->presentationOptions
var $language; 
var $detailsLevel; 
var $tollCategory;
//////variable composant $this->itineraryOptions
var $itineraryType;
var $vehicleType;
var $date;
//////variable composant $this->responseOptions
var $responseElements;
var $mapDefinitionCalculated;
/////taille de la carte
var $mapPixelWidth;
var $mapPixelHeight;
 
	function michelinWebService($log,$pass)
	{
		$this->login=$log;
		$this->pass=$pass;
		//initialise les conteneurs de resultats des requetes
		$this->locationList=NULL;
		$this->itiSteps=Array();
		$this->routeCalculationResult=NULL;
		$this->generateMapResult=NULL;
		$this->distresult=NULL;
		$this->bestMapResult=NULL;
		//Taille d'une carte par defaut
		$this->mapPixelWidth=600;
		$this->mapPixelHeight=600;
		////////////////////////////initialise les variables de $responseOptions / itineraryOptions / presentationOptions\\\\\\\\\\\\\\\\\\\\\\\\\\\\
		//////variable composant $this->presentationOptions
		$this->language=French; 
		$this->detailsLevel=NORMAL_DETAIL_LEVEL;
		$this->tollCategory=CAR;
		//////variable composant $this->itineraryOptions
		$this->itineraryType=RECOMMANDED_ITINERARY;
		$this->vehicleType=LIGHT_VEHICLE;
		$this->date=date('Y-m-d\TH:i:s.Z');
		//////variable composant $this->responseOptions
		$this->responseElements=ITINERARY_TRACE_AND_ITINERARY_ROADMAP;
		$this->mapDefinitionCalculated=MAIN_MAPDEFINITION_ONLY;
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		//INITIALISE des parametres utilisé pour la requete 'getRoute()' ***********
		$this->itineraryOptions = 
		array(
		'itineraryType' => $this->itineraryType, 
		'vehicleType' =>$this->vehicleType, 
		'date' =>$this->date
		);
 
		$this->responseOptions = 
		array(
		'responseElements' =>$this->responseElements,
		'mapDefinitionCalculated' =>$this->mapDefinitionCalculated,
		'mainMapWidth' => $this->mapPixelWidth, 
		'mainMapHeight' => $this->mapPixelHeight
		);
 
		$this->presentationOptions = 
		array(
		'language' => $this->language, 
		'detailsLevel' =>$this->detailsLevel, 
		'tollCategory' => $this->tollCategory
		);
		///////////////////////////////////////////////////////*************
	}
	///////////////////////////////#####################MODIFIER OPTION###############\\\\\\\\\\\\\\\\\\\\\\\\\\\\
	//////////////////////////////////////////itineraryOptions
	function setDate($d)
	{
	$this->date=$d;
	$this->reloadItineraryOptions();
	}
	function setVehicleType($type)
	{
	$this->vehicleType=$type;
	$this->reloadItineraryOptions();
	}
	function setItineraryType($ititype)
	{
	$this->itineraryType=$ititype;
	$this->reloadItineraryOptions();
	}
	function reloadItineraryOptions()
	{
		$this->itineraryOptions = 
		array(
		'itineraryType' => $this->itineraryType, 
		'vehicleType' =>$this->vehicleType, 
		'date' =>$this->date
		);
	}
	//////////////////////////////////////////responseOptions
	function setResponseElements($elem)
	{
	$this->responseElements=$elem;
	$this->reloadResponseOptions();
	}
	function setMapDefinitionCalculated($mapDef)
	{
	$this->mapDefinitionCalculated=$mapDef;
	$this->reloadResponseOptions();
	}
	///////////////////////////
	//setMapSize();
	//param : taille en largeur
	//param : taille en hauteur
	//Desc : change la taille de la carte rendue
	////////////////////////
	function setMapSize($W,$H)
	{
	$this->mapPixelWidth=$W;
	$this->mapPixelHeight=$H;
	//Reinitialise les options de reponse
	$this->reloadResponseOptions();
	}
	function reloadResponseOptions()
	{
	$this->responseOptions = 
		array(
		'responseElements' =>$this->responseElements,
		'mapDefinitionCalculated' =>$this->mapDefinitionCalculated,
		'mainMapWidth' => $this->mapPixelWidth, 
		'mainMapHeight' => $this->mapPixelHeight
		);
	}
	/////////////////////////////////////////presentationOptions
	function setDetailsLevel($ll)
	{
	$this->detailsLevel=$ll;
	$this->reloadPresentationOptions();
	}
	function setLanguage($lang)
	{
	$this->language=$lang;
	$this->reloadPresentationOptions();
	}
	function setTollCategory($cat)
	{
	$this->tollCategory=$cat;
	$this->reloadPresentationOptions();
	}
	function reloadPresentationOptions()
	{
	$this->presentationOptions = 
		array(
		'language' => $this->language, 
		'detailsLevel' =>$this->detailsLevel, 
		'tollCategory' => $this->tollCategory
		);
	}
	///////////////////////////////#################################################\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 
 
	///////////////////////////////
	//getLocationsList()
	//param : variable tableau listeAdresse ex : 'address' =>>adresse, 'cityName' => ville, 'postalCode' =>cp, 'stateName' => '', 'countryCode' =>pays);
	//param2 & 3 : login password michelin WS
	//Desc : retourne une variable tableau a 4 dimension 'FindLocations[]'
	//
	//Desc FindLocations[ ] 	---> Array of found locations. Always an item by supplied address even if no locations are found.
	///////////////////////////////
	function getLocationsList($inputAddresses)
	{
	$geocodingClient=$this->getSoapClient(new wsdl(GEOCODING_WSDL));
 
	$geocodingParams = 
	array(
	'request' => array('addressesList' => $inputAddresses), 
	'check' => "$this->login|$this->pass"
	);
 
	$FindLocations = $geocodingClient->call('getLocationsList', $geocodingParams);
 
		if ($geocodingClient->fault)
		{
		echo '<h2>Fault</h2><pre>';
		print_r($FindLocations);
		echo '</pre>';
		return NULL;
		}
	$this->locationList=$FindLocations;
	return $FindLocations;
	}
	///////////////////////////////
	//fonction : getDistance()
	//Desc : Renvoie la distance en kilometre du point de depart a la derniere adresse fournie
	//Conseil : si besoin seulement distance, utiliser setResponseElements(ITINERARY_TRACE_ONLY); et setDetailsLevel(SYNTHESIS_DETAIL_LEVEL)
	///////////////////////////////
	function getDistance()
	{
	if($this->locationList==NULL)
	die('Vous devez faire appel a getLocationList($listeAdresse) avant d\'utiliser getDistance() ');
 
	$dist=0;
	$distClient=$this->getSoapClient(new wsdl(DISTANCECALCULATION_WSDL));
	$dptPoints=$this->locationList['0']['results']['0']['foundLocation']['geoCoordinates'];
	$arrivalPoints=Array();
	///construi les points d'arrivée
	for($i=1;$i<count($this->locationList);$i++)
	{
	$arrivalPoints[]=$this->locationList[$i]['results']['0']['foundLocation']['geoCoordinates'];
	}
 
	$distanceCalculationRequest = 
	array(
	'request' => array('departurePoint' => $dptPoints,'arrivalPoints' => $arrivalPoints), 
	'check' => "$this->login|$this->pass"
	);
 
	$distresult=$distClient->call('getDistances',$distanceCalculationRequest);
	if($distClient->fault)
	{
	echo '<h2>Fault</h2><pre>';
	print_r($distresult);
	echo '</pre>';
	$this->distresult=NULL;
	return NULL;
	}
	for($i=0;$i<count($distresult);$i++)
	$this->distresult[]=mkDist($distresult[$i]);
 
	return $this->distresult;
	}
	///////////////////////////////////////////
	////getTime()
	///
	///
	///Desc : retourne le temps de trajet entre point de depart et point d'arrivée
	/////////////////////////////////////////////
	function getTime()
	{
	if($this->routeCalculationResult==NULL)
	die('getRoute() doit être appelé avant getTime()');
	else return $this->routeCalculationResult['drivingDirection']['drivingTime'];// ...
	}
 
	///////////////////////////////////////////
	////getRoute()
	///
	///
	///Desc : retourne/set le resultat de l'appel a la fonction getRoute
	/////////////////////////////////////////////
	function getRoute()
	{
	////test si les fonctions necessaire ont bien étés appelées avant
	if($this->itiSteps==NULL)
	die('la fonction createItiSteps() doit être appelé avant');
	////
	$routeCalculationClient  = $this->getSoapClient(new wsdl(ROUTECALCULATION_WSDL));
 
	$routeCalculationRequest = 
	array
	(
	'itiSteps' => $this->itiSteps,
	'itineraryOptions' => $this->itineraryOptions,
	'presentationOptions' => $this->presentationOptions,
	'responseOptions' => $this->responseOptions
	);
 
	$routeCalculationParams  = 
	array
	(
	'request' => $routeCalculationRequest, 
	'check' => "$this->login|$this->pass"
	);
	$this->routeCalculationResult = $routeCalculationClient->call('getRoute', $routeCalculationParams);
		if ($routeCalculationClient->fault){
		echo '<h2>Fault getRoute()</h2><pre>';
		print_r($this->routeCalculationResult );
		echo '</pre>';
		$this->routeCalculationResult=NULL;
		return NULL;
		}
 
	return $this->routeCalculationResult;
	}
 
	///////////////////////////////////////////
	////getMap()
	///
	///
	///Desc : retourne/set le resultat de l'appel a la fonction getMap()
	/////////////////////////////////////////////
	function getMap($newMap=NULL)
	{
	if($this->routeCalculationResult==NULL)
	die('getRoute() doit être appelé avant getMap()');
 
	if($newMap!=NULL)
	$useMap=$newMap;
	else
	$useMap=$this->routeCalculationResult['drivingDirection']['mapDefinition']['scaleDefinition'];
 
	$itipart 		= base64_encode($this->routeCalculationResult['itiTrace']['binaryDesc'][0]['part']);
	$binaryDesc[] 	= array('part' => $itipart);
	$itiTrace 		= array('binaryDesc' => $binaryDesc);
 
	$generateMapClient  = $this->getSoapClient(new wsdl(GENERATEMAP_WSDL));
 
	//PERMET DE METTRe des parametres par defaut. si besoin, ajout d'une methode setMapOption(); qui modifiera $this->mapOption
	if(isset($this->mapOption))
	$option=$this->mapOption;
	else
	$option=Array('imageFormat' => FORMAT_GIF);
 
	//IDEM que mapOption
	if(isset($this->pinLogos))
	$pinLogos=$this->pinLogos;
	else
	$pinLogos=NULL;
 
	$generateMapRequest = array(
	'mapDefinition' => $useMap, 
	'options' => $option, 
	'itiTrace' => $itiTrace, 
	'pinLogos' => $pinLogos
	);
 
	$generateMapParams   = array(
	'request' => $generateMapRequest, 
	'check' => "$this->login|$this->pass");
 
	$generateMapResult = $generateMapClient->call('getMap', $generateMapParams);
 
	if ($generateMapClient->fault) {
		echo '<h2>Fault</h2><pre>';
		print_r($generateMapResult);
		echo '</pre>';
		return NULL;
	} 
	$this->generateMapResult=$generateMapResult;
	return $generateMapResult;
	}
	///////////////////////////////////////////
	////getBestMapDefinition()
	///[param : precision en métres] 
	///
	///retourne un "objet" carte "optimisé"
	//utilisé par exemple pour zoomer
	///pour que la nouvelle carte soit celle prise en compte, utilisez "reloadMap();"
	/////////////////////////////////////////////
	function getBestMapDefinition($pixelSize=NULL)
	{
	if($this->locationList==NULL)
	die('getLocationList(AdresseList) doit être appelé avant d\'utiliser cette Méthode');
	//die(phpinfo());
	$bestMapClient  = $this->getSoapClient(new wsdl(GETBESTMAPDEFINITION_WSDL));
	$locationDefinition=Array();
 
	for($i=0;$i<count($this->locationList);$i++)
	{
	$locationDefinition[] =array(
	'geoCoordinate' => 
		array(
		 'id'=>$this->locationList[$i]['results']['0']['foundLocation']['id'],
		 'latitude' => $this->locationList[$i]['results']['0']['foundLocation']['geoCoordinates']['latitude'], 
		 'longitude' => $this->locationList[$i]['results']['0']['foundLocation']['geoCoordinates']['longitude']
		 )
	 );
	}
	$mapRequest=Array(
	"pixelWidth"=>$this->mapPixelWidth,
	"pixelHeight"=>$this->mapPixelHeight,
	"locations"=>$locationDefinition
	);
 
	$mapDefinitionRequest=Array(
	"check"=>$this->login.'|'.$this->pass,
	"request"=>$mapRequest
	);
 
	$bestMapResult =$bestMapClient->call('getMapDefinition',$mapDefinitionRequest);
 
		if($bestMapClient->fault)
		{
		echo '<h2>Fault</h2><pre>';
		print_r($bestMapResult);
		echo '</pre>';
		$this->bestMapResult=NULL;
		return NULL;
		}
		if($pixelSize!==NULL)
		$bestMapResult['scaleDefinition']['pixelSize']=$pixelSize;
 
	$this->bestMapResult=$bestMapResult;
	/*echo '<pre>';
	print_r($bestMapResult);
	die();*/
	return $bestMapResult;
	}
	///////////////////////////////////////////
	////reloadMap();
	///
	///
	///Desc :Recharge une carte appres modification
	/////////////////////////////////////////////
 
	function reloadMap()
	{
		if($this->bestMapResult['scaleDefinition']!=NULL)
		$this->getMap($this->bestMapResult['scaleDefinition']);
		else
		{
		if($this->routeCalculationResult['drivingDirection']['mapDefinition']['scaleDefinition']!=NULL)
		$this->getMap($this->routeCalculationResult['drivingDirection']['mapDefinition']['scaleDefinition']);
		else
		{die('pas de definition de carte pour regenerer la carte');return false;}
		}
		return true;
	}
	///////////////////////////
	//
	//Descr : Retourne l'url de la carte pour affichage
	////////////////////////////
	function getMapUri()
	{
	if($this->generateMapResult==NULL)
	die('\'">;</pre></iframe></img></script><b>Erreur</b><br /> La carte n\'a pas été definie');
	else
	return $this->generateMapResult['url'];
	}
	///////////////////////////
	//
	//Descr : Retourne le binaire de l'image généré
	////////////////////////////
	function getMapBin()
	{
	if($this->generateMapResult==NULL)
	die('la fonction getMap doit être appelé avant');
 
	$url=$this->generateMapResult['url'];
	$toSplit=strpos($url,'/',8);//permet d'eviter les deux premiers '//'
	$domain=str_replace('http://','',substr($url,'0',$toSplit));
	$leReste=substr($url,$toSplit,strlen($url));
	/*echo $domain;
	echo '<br />'.$leReste.'<br />';
	echo $toSplit;*/
	$errno=NULL;
	$errstr=NULL;
	$sock = fsockopen ($domain, 80, $errno, $errstr, 30);
	$content=NULL;
	if (!$sock) 
	{
	echo "Une erreur s'est produite<br>\n";
	echo "Numéro d'erreur : $errno<br>\n";
	echo "Description :  $errstr<br>\n";
	}else{
	$content='';
		fputs ($sock, "GET  $leReste HTTP/1.0\r\n\r\n");
		while (!feof($sock)) {
		$content.=fgets ($sock,128);
		}
		$content=preg_replace("!^(.*\r\n)*!i","",$content);//retire les entetes HTTP
	}
 
	fclose($sock);
	return $content;
	}
	///////////////////////////
	//
	//Descr : memorise les identifiants de 'locationList' ( resultat des differents points d'etapes de dest1 a dest 2 )
	////////////////////////////
	function createItiSteps()
	{
	$this->itiSteps=Array();//Ecrase les anciennes valeurs...
	if($this->locationList==NULL)
	die('getLocationsList() doit être appelé avant createItiSteps');
 
		for($i=0;$i<count($this->locationList);$i++)
		{
			$this->itiSteps[] = 
			array
			(
			'location' => Array('id' =>$this->locationList[$i]['results']['0']['foundLocation']['id'])
			);
		}
	}
	//////////////////////////////////
	//getSoapClient()
	//
	//param : $WSDL = objet de type WSDL lib nusoap
	//
	//Descr : RENVOIE UN CLIENT SOAP
	/////////////////////////////////////
	function getSoapClient($WSDL)
	{
	$proxyhost = '';
	$proxyport = '';
	$proxyusername = '';
	$proxypassword = '';
	$spclient  = new soapclient($WSDL, true, $proxyhost, $proxyport, $proxyusername, $proxypassword);
	$err = $spclient->getError();
		if ($err)
		{
		echo '<h2>SOAP Constructor error</h2><pre>' . $err . '</pre>';
		return NULL;
		}
		else
		return $spclient;
	}
}
////////////////////////////
//Fonction javascript retranscrite en PHP du SDK de michelin
// ( utilisé pour le calcul de distance )
///////////////////////////
function mkDist($i)
{
if ($i < 101) return (closer($i,10) ." m");
if (($i > 100)&&($i < 501)) return (closer($i,50) ." m");
if (($i > 500)&&($i< 2001)) return ((round(closer($i,100)/100)/10));//KM
if (($i > 2000)&&($i < 10001)) return ((round(closer($i,500)/100)/10));//KM
if ($i > 10000) return (round(closer($i,1000)/1000));//KM
}
function closer($n,$d)
{
	$dNeg = 0;
	$dPos = 0;
	while (($n-$dNeg) % $d != 0) $dNeg++;
	while (($dPos+$n) % $d != 0) $dPos++;
	return (($dPos <= $dNeg) ? ($dPos+$n) : ($n-$dNeg));
}

je precise aussi que l'API de michelin ne permet pas d'exploiter le 1/4 des Webservices disponibles...
j'en ais donc rajouté, en fonction de mes besoin, mais cette classe va surement evoluer, car elle non plus n'exploite pas tout les webservices disponibles. ( notamment le PinLogo ( mettre des images par exemple, sur une ville, un parking etc..) et MapManagement )

Liens :

Michelin webservice
( le fichier de constante est dans la section "telechargement" )
NUSOAP

**titoumimi** · 23/01/2006, 15h40

Créer un "chemin de fer" (suite de lien qui donne notre position dans l'arborescence du site) :

Supposons d'abord que vous avez une base de donnée avec une table pour vos pages (nommons la PAGES, parfaitement au hasard).

Supposons ensuite que dans cette table, vous auez un champ Id_page (identifiant de la page en cours, un auto increment fera très bien l'affaire), un autre appelé Id_parent (l'ID de la page parent, le N+1 dans l'organigramme), et un champ Titre (contenant le titre de votre page).

La seule règle imposée sera que l'Id_parent de la page racine sera 0.

Nous pouvons à présent passer au code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
function recur_chemin($idpage) {
    // on définit la variable pour éviter le warning
    $chemin_complet = "";
    // Si l'id de la page en cours est différent de 0 
    // (0 = page parente de la page racine = inexistante)
    if ($idpage != 0) {
        // on récupère les informations de la page en cours dans la DB
        $strSQL = "SELECT * FROM PAGES WHERE Id_page=".$idpage;
        $resultat = requete_SQL($strSQL);
        $tabl_result = mysql_fetch_array($resultat);
 
        $titrepage = $tabl_result['Titre'];
        $idparent = $tabl_result['Id_parent'];
 
        // création du lien vers la page en cours
        $chemin_page_en_cours = " -> <a href=\"index.php?id_p=".$idpage."\">".$titrepage."</a>";
 
        // Concaténation du lien de la page N-1 et
        // du lien de la page en cours
        $chemin_complet = recur_chemin($idparent).$chemin_page_en_cours;
    }
    //renvoie le chemin complet
    return $chemin_complet;
}

Il nous suffit maintenant d'appeler cette fonction à l'endroit indiqué comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
$chemin_de_fer = recur_chemin($id_de_la_page_en_cours);
echo $chemin_de_fer;

J'espère que ce petit bout de script sera utile

**SnakemaN** · 05/07/2006, 16h30

CALCUL DE DUREE EN PHP

Voici le code d'un petit truc que j'avais bricolé car je galérais à calculer les dates...

C'est un formulaire permettant la saisie de 2 Heures puis calcul la différence entre les deux quelques soit la difference entre les heures dans le temps

Sur recommandation de Mr Kerod voici :

[edit] : maj cause oubli de gestion de variable super-globale

<?php
/************************************************************************************
* COde PHP montrant un peu la gestion des Dates en Heures en php *
* notament le calcul entre deux heures indifferement dans le temps, *
* l'heure 1 peut etre plus tôt ou plus tard que l'heure 2 et inversement, le script *
* fera le calcul suivant un journée de 24h *
* Notes : Le format utilisé est le format 24h avec hh:mm:ss *
* mais on peut le changer facilement ;p *
* *
*@author =)C!S(=_SnaKemaN *
*@version 1.0 *
*@version 1.2
+ Contrôle des variable super-globale (php 4.3.10 oblige...) *
************************************************************************************/
//Controle des valeurs, c'est certes aberrant mais c'est un exemple apres vous gerez
//comme vous voulez
if(isset($_POST['heure1']))
$my_strh1=$_POST['heure1'];
else
$_POST['heure1'] = "00-00-00";

if(isset($_POST['heure2']))
$my_strh2=$_POST['heure2'];
else
$_POST['heure2'] = "00-00-00";

if(!isset($h3))
$h3 = 0;

echo "<TABLE cellpadding=5 cellspacing=0 align=center border=1>";
echo "<TR>";
echo "<TD>";
//note Changer le "action" pour avoir le nom de votre page ou se fera le traitement
echo "<FORM method=\"POST\" name=\"mf\" action=\"./calcul_date.php\">";
echo "<TABLE cellpadding=5 cellspacing=0 align=center border=1>";
echo "<TR>";
echo "<TD><strong>Heure 1:</strong></TD>";
//Une heure est deja présaisie pour faciliter le test
echo "<TD><INPUT type\"text\" name=\"heure1\" value=\"07:00:00\"></TD>";
echo "</TR>";
echo "<TR>";
echo "<TD><strong>Heure 2 :</strong></TD>";
//Une heure est deja présaisie pour faciliter le test
echo "<TD><INPUT type\"text\" name=\"heure2\" value=\"17:00:00\"></TD>";
echo "</TR>";
echo "<TR>";
echo "<TD colspan=2 align=center>";
echo "<INPUT type=\"submit\" name=\"go\" value=\"Valider\">";
echo "</TD>";
echo "</TR>";
echo "</TABLE>";
echo "</FORM>";
echo "</TD>";
echo "<TD>";
echo "<strong>Date et heure courante :</strong><br>";
echo date('d/m/Y @ H:i:s',time());
echo "<br>";
echo "</TD>";
echo "<TD>";
$my_strh1=$_POST['heure1'];
$my_strh2=$_POST['heure2'];
//Conversion des heures en TimeStamp
$h1=strtotime($my_strh1);
$h2=strtotime($my_strh2);
//Si la deuxieme heure est bien plus tard que la premiere
if($h2 > $h1)
{$h3=($h2-$h1);
}
//Si c'est la premiere heure qui est plus tard que la deuxieme
if($h1 > $h2)
{$h3=86400-($h1-$h2)-3600;
}
echo "<strong>Heure 1 :</strong>".$my_strh1."<br>";
@$date1 = getdate($h1);
//Controle du format de l'heure h 00 < hh < 24 ; 00 < mm < 59 ; 00 < ss < 59
if($h1 == -1 ){
echo "Heure_1 incorrecte ! <br>";
}else{
echo "Heure_1 OK <br>";

echo "<strong>Heure 2 :</strong>".$my_strh2."<br>";
//Controle du format de l'heure h 00 < hh < 24 ; 00 < mm < 59 ; 00 < ss < 59
@$date2 = getdate($h2);
if($h2 == -1 ){
echo "Heure_2 incorrecte ! <br>";
}else{
echo "Heure_2 OK <br>";

echo "<strong>Valeur de h1 :</strong>".$h1."<br>";
echo "<strong>Valeur de h2 :</strong>".$h2."<br>";
$h3=$h3-3600;//Retrait d'une heure de decalage o_O
echo "<strong>Valeur de h3 :</strong>".$h3."<br>";
echo "<strong>Decalage heure :</strong>";
//reconversion du timestamp en heure préformatée (ici H M)
echo strftime("%H:%M",$h3);
}//Fin if else heure 2
}//Fin if else heure 1
echo "<br>";
echo "</TD>";
//Et vouala ^_^
echo "</TR>";
echo "</TABLE>";
?>

Colorez votre code PHP sur les forums grâce à Developpez.comBonne journée

SKN

**guitou12** · 07/07/2006, 17h27

Une petite fonction sans prétentions mais qui me sert grandement

Récupération rapide des variables de formulaire/sessions/Url/Cookies

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/********************
      RECUP VAR
*********************/
/** 
* Récupère les vars d'url, de session suivant les paramètres passés
* get (resp. post) convertit en majuscules les valeurs alors que get_lower (resp.post_lower) recupere la valeur brute
* @param $param Le type de récupération (get / post / session etc)
* @param $nom_var Le nom de la variable à récupérer
* @param $defaut_val La valeur par défaut de retour si la variable n'est pas définie
* @return La valeur de la variable
*/
function recup_var($param,$nom_var,$defaut_val)
{
    switch($param)
    {
        case 'get':
            if (isset ($_GET[$nom_var])) $res=$_GET[$nom_var]; else $res=$defaut_val; break;
        case 'post':
            if (isset ($_POST[$nom_var])) $res=$_POST[$nom_var]; else $res=$defaut_val; break;
        case 'session':
            if (isset ($_SESSION[$nom_var])) $res=$_SESSION[$nom_var]; else $res=$defaut_val; break;
               case 'cookie':
            if (isset ($_COOKIE[$nom_var])) $res=$_COOKIE[$nom_var]; else $res=$defaut_val; break;
    }
    return $res;
}

**Are-no** · 24/07/2006, 20h47

Avoir la date en Français

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
// Avoir la date en Français
// <a href="mailto:are-no@emiloo.com">are-no@emiloo.com</a>
// Ca marche comme la fonction date()
 
function date_fr($format){
if (func_num_args()=="2"):$horodatage=func_get_arg(1);else:$horodatage=time();endif;
$date_fr = date($format, $horodatage);
$traduction = array( 
"Monday" => "Lundi", "Tuesday" => "Mardi", "Wednesday" => "Mercredi", "Thursday" => "Jeudi", "Friday" => "Vendredi", "Saturday" => "Samedi", "Sunday" => "Dimanche",
"Mon" => "Lun", "Tue" => "Mar", "Wed" => "Mer", "Thu" => "Jeu", "Fri" => "Ven", "Sat" => "Sam", "Sun" => "Dim",
"January" => "janvier", "February" => "fevrier", "March" => "mars", "April" => "avril", "May" => "mai", "June" => "juin", "July" => "juillet", "August" => "août", "September" => "septembre", "October" => "octobre", "November" => "novembre", "December" => "decembre",
"Jan" => "jan", "Feb" => "fev", "Mar" => "mar", "Apr" => "avr", "May" => "mai", "Jun" => "jui", "Jul" => "juil", "Aug" => "aoû", "Sep" => "sep", "Oct" => "oct", "Nov" => "nov", "Dec" => "dec"
);
$date_fr = strtr($date_fr , $traduction); 
return($date_fr);
}

**ePoX** · 09/08/2006, 23h45

Dans le cadre d'un développement j'avais besoin de créer un système de *plug in*.
Pour cela j'avais besoin de créer dans mes classes des points d'entrées utilisable par des classes externes que je connais pas encore.

Donc le but est de faire cummuniquer une classe A avec une classe B, sans que A ne connaisse B.

Pour cela j'ai fait une petite classe d'evenement. C'est surement améliorable, les vieux de la vieille me feront signe

Mais bon sa remplit le but fixer dans le paragraphe du dessus.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
class Evenement
{
    //////////////////////////////////////////////////
    //    propriétés
    //////////////////////////////////////////////////
    protected $p_abonnes;
 
 
    public function __construct()
    {
        $this->p_abonnes = new ArrayObject();
    }
 
    public function attacherUnAbonne( $classe , $methode )
    {
        $this->p_abonnes[] = new Evenement_Abonne($classe , $methode);
    }
 
    public function detacherUnAbonne( $classe , $methode )
    {
        foreach( $this->p_abonnes as $cle => $abonne )
            if( $abonne->classe == $classe && $abonne->methode == $methode)
                unset($this->p_abonnes[$cle]);
    }
 
    public function declencher()
    {
        $args = func_get_args();
 
        foreach( $this->p_abonnes as $abonne )
            if( method_exists($abonne->classe, $abonne->methode ) )
                call_user_func_array(array($abonne->classe,$abonne->methode), &$args); 
    }
}
 
class Evenement_Abonne
{
    //////////////////////////////////////////////////
    //    propriétés
    //////////////////////////////////////////////////
    protected $p_classe;
    protected $p_methode;
 
    //////////////////////////////////////////////////
    //    
    //////////////////////////////////////////////////
    public function __construct( $classe , $methode )
    {
        $this->p_classe     = $classe;
        $this->p_methode     = $methode;
    }
 
    //////////////////////////////////////////////////
    //
    //////////////////////////////////////////////////
    public function __get( $prop )
    {
        switch( $prop )
        {
            case "classe":
                return $this->p_classe;
            break;
            case "methode":
                return $this->p_methode;
            break;
        }
 
        throw new Exception("Propriété ".$prop." inconnue dans la classe ".(__CLASS__)."");
    }
 
    //////////////////////////////////////////////////
    //
    //////////////////////////////////////////////////
    public function __set( $prop , $value )
    {
        switch( $prop )
        {
            case "classe":
                $this->p_classe = $value;
            break;
            case "methode":
                $this->p_methode = $value;
            break;
            default:
                throw new Exception("Propriété ".$prop." inconnue dans la classe ".(__CLASS__)."");
            break;
        }
    }
}

Exemple d'usage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
class Papa
{
    public $lorsDeLappel; // levenement à declencher
 
    public function __construct()
    {
        $this->lorsDeLappel = new Evenement();
    }
 
    public function faireLAppel()
    {
        $Objet = new stdClass();
        var_dump($Objet);
        $this->lorsDeLappel->declencher($Objet);
    }
}
 
class Enfant
{
    public $nom;
 
    public function repondrePresent( $Objet )
    {
        echo "<br /><strong>".$this->nom." à répondu</strong> : je suis ici.<br />";
        var_dump($Objet); // verification que l'objet reçu est bien envoyé par référence
    }
}
 
$Papa = new Papa();
for( $i=0; $i< 15; $i++)
{
    $Enfant = new Enfant();
    $Enfant->nom = $i;
    $Papa->lorsDeLappel->attacherUnAbonne( $Enfant , "repondrePresent" );
}
 
$Papa->faireLAppel();

Enfin sa reste qu'un callback amélioré hein. Rien d'exceptionnel c'est extremement rudimentaire.

bbye

**titoumimi** · 23/01/2006, 16h08

En reprenant la même structure de base que précédement, nous allons maintenant générer un plan du site sous forme de listes imbriquées, qui se mettra à jour tout seul dès que la base sera modifiée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
// Affiche le plan du site
// Paramètres : Id de la page en cours (0 lors du premier passage) pour lister toutes les pages filles
 
function affiche_plan_site($id_page) {
    // Sélectionne l'ensemble des pages filles de la page courante
    $strSQL = "SELECT * FROM PAGES WHERE id_parent = ".$id_page;
    $resultat = requete_SQL($strSQL);
    // Si la requête a renvoyé des résultats
    if (mysql_affected_rows() !=0) {
        echo "<ul>\n";
        // Tant qu'il y a des pages filles, on affiche un lien vers elle
        // et pour chacune d'elle, on rappelle la fonction
        while ($tabl_result = mysql_fetch_array($resultat)) {
            echo "<li>\n";
            echo "<a href=\"index.php?id_p=".$tabl_result['Id_page']."\">";
            echo $tabl_result['Titre_'];
            echo "</a>\n";
            affiche_plan_site($tabl_result['Id_page']);
            echo "</li>\n";
        }
        echo "</ul>\n";
    }
}

**Yogui** · 08/02/2006, 21h31

Script de sauvegarde de base de données volumineuse (n'importe quelle taille)

Salut à tous

Je m'occupe d'un forum phpBB et, comme tous les forums, il a fini par tellement grossir que le module de sauvegarde de la BDD inclus dans l'ACP de phpBB n'a plus suffi.
Les quelques scripts trouvés sur le Net ne me convenaient pas ou bien l'auteur en avait bridé l'usage (ce qui ne me convenait pas non plus) et je me suis dit que, au diable l'avarice, autant écrire le mien, ce serait un bon exercice de toute manière.

Je suis assez satisfait du résultat donc je vous le propose ici.
Attention, mon code est phpBB-specific, c'est-à-dire que j'utilise la classe d'astraction de BDD, l'en-tête de page, les sessions, la stratégie de sécurité et quelques tables de phpBB.
Cela dit, il ne devrait pas être trop complexe de généraliser le script si le besoin s'en faisait sentir. J'ai préféré faire ainsi pour le moment, voilà tout.

Je vous explique son fonctionnement : ce script détermine la structure des tables d'une base de données, essaie de trouver tout seul les clés primaires si elles n'existent pas (c'est parfois le cas lorsqu'il s'agit de phpBB) et les utilise pour récupérer les enregistrements.
Au fur et à mesure de la récupération des données, tout est sauvegardé dans des fichiers texte compressés.
Lorsque le timeout se rapproche ou lorsque le disque est plein, le script s'arrête de lui-même et affiche un bouton pour que l'on puisse lui dire de continuer la sauvegarde à partir d'où il en était.
Des liens sont affichés pour télécharger les archives compressées mais j'ai préféré éviter d'automatiser leur suppression, afin d'éviter les bourdes. C'est si vite fait de cocher une case trop vite et de devoir tout recommencer...

Selon ce que j'ai testé, le script fonctionne.
Cependant, afin d'éviter de se retrouver avec des incohérences dans la BDD sauvegardée, il est préférable de toujours laisser quelques Mio libres sur le FTP (ne pas attendre que le script ne puisse plus écrire), juste au cas où.

Pour installer le script, vous aurez besoin de :

phpBB

créer la table suivante (n'oubliez pas votre préfixe) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
CREATE TABLE `phpbb_db_backup` (
  `table_name` varchar(255) NOT NULL default '',
  `offset` int(11) NOT NULL default '0',
  PRIMARY KEY  (`table_name`)
)

définir la constante qui contient le nom de la table de tracking :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
define('BACKUP_TRACKING_TABLE', $table_prefix.'db_backup_tracking');
```
cela peut être fait dans le script lui-même (au début) ou bien, et c'est ma recommandation, dans le script de phpBB qui est prévu à cet effet (habituellement /includes/constants.php)
copier le script dans le répertoire des scripts d'administration (habituellement dans le répertoire /admin de votre forum)

Pour l'utiliser, allez dans l'ACP et cliquez sur le nouveau lien du menu, puis suivez les instructions.

N.B. : mon pseudo habituel n'est pas Kirkis mais Yogui.

[ Télécharger le script ]

**Mayhem** · 13/02/2006, 14h05

Parser un fichier XML avec PHP 4 et EXPAT

J'ai dû réaliser un site web il y a quelques temps, et mon hébérgeur ne disposait que de PHP 4 et d'EXPAT.
Je n'ai pas trouvé EXPAT très pratique et je voulais pouvoir utiliser mes fichiers XML un peu comme l'on m'avait appri avec Microsoft et son ActiveX XMLDOM.
Il existe des scripts pour PHP 5 (il y en a d'ailleurs un dans la FAQ) mais je n'en ai pas trouvé pour PHP 4.
Je vous présente donc celui que j'ai réalisé à l'aide du même exemple que dans la FAQ :

Le fichier parsing.php contient 2 classes : tag et XML_Parser

- Classe tag :

<?php
/*** Classe gérant les balises contenues dans le fichier XML
* @param $tag_array Tableau contenant les balises filles de la balise actuelle
* @param $name Nom de la balise actuelle
* @param $data Texte éventuel dans la balise
* @param $parentTag Balise parente de la balise actuelle
* @param $attr_array Attributs éventuels de la balise actuelle
*/

class tag
{
    var $tag_array;
    var $name;
    var $data;
    var $parentTag;
    var $attr_array;

    /*** Constructeur de la classe tag */
    function tag()
    {
        $this->tag_array = array();
        $this->data = "";
        $this->name = "";
        $this->parentTag = NULL;
    }

    /*** Recherche la liste des balises (objets tag) contenus dans la balise désignée par le paramètre $name
    * @param $name Nom de la balise recherchée
    * @return Un tableau d'objets de type tag contenant la liste des balises parentes à la balise $name
    */
    function getElementsByTagName($name)
    {
        $tag_list = new tag();
        foreach ($this->tag_array as $tag)
        {
            if($tag->name == $name)
            {
                array_push($tag_list->tag_array, $tag);
            }
        }
        return $tag_list;
    }
    
    /*** Récupère le texte contenu entre les balises en désignant la balises concernée par son index dans un tableau d'objets tag renvoyé par 

getElementsByTagName
    * @index $index index de l'élément du tableau
    * @return Un tableau d'objets de type tag contenant la liste des balises parentes à la balise $name
    */
    function getDataItem($index)
    {
        return $this->tag_array[$index]->data;
    }
    
    /*** Retourne le nombre de balises filles de la balise actuelle
    * @return le nombre de balises filles de la balise actuelle
    */
    function getSize()
    {
        return count($this->tag_array);
    }
}
?>

Phpsyntaxcolor powered by decabodi.com

- Classe XML_Parser :

<?php
/*** Classe gérant le parseur XML EXPAT
* @param $xml_parser Tableau contenant les balises filles de la balise actuelle
* @param $xml_file Fichier XML à parser
* @param $root Racine du document XML
* @param $parentTag Balise parente de la balise actuelle
* @param $currentTag Balise actuellement parsée
*/

class XML_Parser
{
    var $xml_parser;
    var $xml_file;
    var $root;
    var $parentTag;
    var $currentTag;

    /*** retourne un objet tag correspondant à la racine du document XML
    * @return un objet tag correspondant à la racine du document XML
    */
    function documentElement()
    {
        return $this->root->tag_array[0];
    }
    
    /*** constructeur de la classe XML_Parser */
    function XML_Parser()
    {
        $this->xml_parser = xml_parser_create();
        xml_set_object($this->xml_parser, $this);
        xml_set_element_handler($this->xml_parser, "startTag", "endTag");
        xml_set_character_data_handler($this->xml_parser, "characterData");            

        $this->xml_file = "";
        $this->root = new tag();
        $this->parentTag = &$this->root;
        $this->currentTag = NULL;
        }

    /*** Destructeur de la classe XML_Parser (à appeler explicitement car PHP 4 ne gère par les destructeurs de classe) */
    function destroy()
    {
        xml_parser_free($this->xml_parser);
    }

    /*** Fonction Callback appelée par le parseur XML EXPAT lors de l'ouverture d'une balise dans le fichier XML
    * @param $parser Parseur XML
    * @param $name Nom de la balise parsée
    * @param $attrs Attributs éventuels de la balise parsée
    */
    function startTag($parser, $name, $attrs)
    {
        array_push($this->parentTag->tag_array, new tag());
        $indice = count($this->parentTag->tag_array)-1;
        $this->parentTag->tag_array[$indice]->name = $name;
        $this->parentTag->tag_array[$indice]->parentTag = &$this->parentTag;
        $attrs?$this->parentTag->tag_array[$indice]->attr_array = $attrs:0;
        $this->parentTag = &$this->parentTag->tag_array[$indice];
        $this->currentTag = &$this->parentTag;
            
    }

    /*** Fonction Callback appelée par le parseur XML EXPAT lors de la fermeture d'une balise dans le fichier XML
    * @param $parser Parseur XML
    * @param $name Nom de la balise parsée
    */
    function endTag($parser, $name)
    {
        $this->parentTag = &$this->parentTag->parentTag;
    }

    /*** Fonction Callback appelée par le parseur XML EXPAT lors de la rencontre de texte ne correspondant par à une balise
    * @param $parser Parseur XML
    * @param $data Texte lu
    */
    function characterData($parser, $data)
    {
        $this->currentTag->data .= $data;
    }

    /*** Charge le fichier XML $xml_file et complète $root */
    function load()
    {
            if (!($fp = fopen($this->xml_file, "r")))
        {
                    die("could not open XML input");
            }

        while ($data = fread($fp, 4096))
        {
            if (!xml_parse($this->xml_parser, $data, feof($fp)))
            {
                die(sprintf("XML error: %s at line %d",
                    xml_error_string(xml_get_error_code($this->xml_parser)),
                    xml_get_current_line_number($this->xml_parser)));
            }
        }

    }

}
?>

Phpsyntaxcolor powered by decabodi.com

Un exemple illustrant l'utilisation à l'aide du même exemple que la FAQ (http://php.developpez.com/sources/?page=xml#parsexml)

- Fichier XML :

<?xml version="1.0" encoding="ISO-8859-1"?>
<librairie>
   <livre code="15424">
      <isbn>1234567890-00-00</isbn>
      <titre>Mon premier livre</titre>
   </livre>
   <livre code="15425">
      <isbn>9876543210-00-00</isbn>
      <titre>Son second livre</titre>
   </livre>
</librairie>
Phpsyntaxcolor powered by decabodi.com

- exemple.php

<?php

require("parsing.php");

$parser = new XML_Parser();
$parser->xml_file = "exemple.xml";
$parser->load();
$racine = $parser->documentElement();
$livres = $racine->getElementsByTagName('LIVRE');

foreach($livres->tag_array as $livre)
{
    $code = $livre->attr_array['CODE'];
    $isbn = $livre->getDataItem(0);
    $titre = $livre->getDataItem(1);
    echo '<p>Code du livre : ' . $code . ' ISBN : ' . $isbn . ' Titre : ' . $titre . '</p>';
}

$parser->destroy();

?>

Phpsyntaxcolor powered by decabodi.com

- Sortie :

<?php
Code du livre : 15424 ISBN : 1234567890-00-00 Titre : Mon premier livre

Code du livre : 15425 ISBN : 9876543210-00-00 Titre : Son second livre 
?>

Phpsyntaxcolor powered by decabodi.com

Il y a sans doute des choses à améliorer mais j'ai déjà eu l'occasion de m'en servir sur un site et ca fonctionne correctement (pour l'instant

)

a+

**XtofRoland** · 13/02/2006, 14h27

Cette classe génère des formulaires d'après une requete sql.
ici en deux classes car j'ai deux bases de données diff.
je n'ai pas d'hebergeur...

en passant si qqn a la motivation de mettre un script de ce genre en ligne..

pour faciliter la lecture des codes afficher ici ;-)

<?
//$obj->addCSS("f.css");
include "formabs.inc";
class formms extends formabs {
var $db;
function formms($SQL ){

$this->db = odbc_connect("secret","secret","secret");
$req = odbc_exec( $this->db,$SQL);

$fieldName = array();
$fieldLen = array();
$fieldType = array();
$fieldValue = array();

$count = odbc_num_fields( $req )+1;
for ($i=1;$i<$count ;$i++){
$fieldName[$i] = odbc_field_name($req, $i); // nom du champ
$fieldLen[$i] = odbc_field_len($req, $i); // longueur
$fieldType[$i] = odbc_field_type($req, $i); // type du champ
}

odbc_fetch_row($req);
for ($i=1;$i<$count ;$i++){
$fieldValue[$i] = "";
$fieldValue[$i] = odbc_result($req,$i);
}
$this->SQL = $SQL;
$SQL = strtoupper($SQL);
$SQL = str_replace(" FROM ", "[*%&]", $SQL );
$SQL = str_replace(" WHERE ", "[*%&]", $SQL);
list($fields,$this->table,$whereclause) = explode("[*%&]",$SQL);

$this->numfields = $count;
for ($i=1;$i< $this->numfields ; $i++){
$this->fieldErrMsg[$i] = "";
$this->test[$i] = "";
$row = new row($fieldName[$i], $fieldLen[$i],$fieldType[$i]);
$row->fieldValue= $fieldValue[$i];
$this->rows[$fieldName[$i]] = $row ;
}
parent::formabs();
}//end construct
function nextSequence($col){
$tab = $this->table ;
$SQL = "select max(".$col.") from ".$tab;
$req = odbc_exec( $this->db,$SQL);
odbc_fetch_row($req);
return odbc_result($req,1) + 1;
}

}//end class
?>

voici la deuxieme:

<?
//$obj->addCSS("f.css");
//array_keys
define("CONSULT", 0);
define("MODIFY", 1);
define("ADD", 2);

class row{
/*

*/
var $label = ""; //
var $fieldName = ""; //nom du champs en db
var $fieldLen = "";
var $fieldType = "";
var $fieldValue = "";//sera envoyé a la database
var $visibleValue="";//sera affiché
var $fieldErrMsg= "";
var $visible = true;/*Un champ peut etre invisible
- pour permettre des tests
- car rempli automatiquement et pour le design */
var $protected = false;
var $key = false;
var $list = array();
var $auto = "";

function row($fieldName, $fieldLen, $fieldType ){
$this->fieldName = $fieldName;
$this->label = $fieldName;
$this->fieldLen = $fieldLen;
$this->fieldType = $fieldType;
}
function toDB( ){
$rtn = $this->fieldValue;
$rtn = addslashes($rtn);
return $rtn;
}
function show( $mode ){
$rtn = "";
if ($mode && !$this->protected ){
switch($this->fieldType){
case 'text':
$rtn = "<TEXTAREA name='".$this->fieldName."' rows=4 cols=40>".nl2br($this->fieldValue)."</TEXTAREA>";
break;
default:
$rtn = "<input type=text name='".$this->fieldName."' value='".$this->fieldValue."'>";
break;

}
}else{//consult
/*if ($this->fieldName == $this->primaryKey){
$form .= "<input name=".$this->rows[$i]->fieldName." type=hidden value=".$this->rows[$i]->fieldValue.">";
if ( ! $this->fieldValue ) $form .= " automatique ";
}*/

$rtn = ($this->fieldValue == '' && $this->auto )?'automatique':$this->fieldValue;
}
return $rtn;
}//end show
function test( ){

}
}//end class

class formabs{
var $mode = CONSULT;
var $table = "";
var $SQL = "";
var $rows = array();
var $numfields = 0 ; //nombre de rows
var $ErrMsg = "";

function formabs( ){
if (isset($_POST)){
foreach ($_POST as $key => $val) {
if(isset($this->rows[$key])) $this->rows[$key]->fieldValue = $val;
}
}
}//end _construct
function nextSequence($col, $tab){}//end abstract fct
function mode($mode ){
$this->mode = $mode;
}//end mode
function protect($field ){
$this->rows[$field]->protected = true;
}//end protect
function setAuto($field, $fct ){
$this->protect($field);
$this->rows[$field]->auto = $fct;
}//end setAuto
function primary($field ){
$this->rows[$field]->key = true;
$this->setAuto($field, 'nextSequence');
}//end primary
function traduction($dico ){
foreach ($dico as $key => $val) if (isset($this->rows[$key]) && $val != "")$this->rows[$key]->label = $val;
}//end traduction
function getValue($field){
return (isset($this->rows[$field]))? $this->rows[$field]->fieldValue: O;
}//end getValue
function show(){
$count = $this->numfields;
$form = "<form method=POST action=".$_SERVER['PHP_SELF']."?mode=".$this->mode."> ";
$form .= "<table width=500 cellSpacing=0 cellPadding=0><TBODY>";
$i = 0;
foreach ($this->rows as $key => $row) {
if ($row->visible){
//libellé
$i++;
$form .= "<tr class=data".(($i % 2) + 1) ."><td>".$row->label."</td>";
//icone
$form .= "<td width=16>";
if ( $row->fieldErrMsg != "" ) $form .= "<img src='"._HOMEPAGE."/Img/b_drop.png'>";
$form .= "</td>";
//champ
$form .= "<td>";
$form .= $row->show($this->mode) ;
$form .= "</td><td> </td></tr>";
}
}
$form .= "<TBODY></table>";

if ( $this->mode == MODIFY || $this->mode == ADD ){
$form .= " <table width=100%><tr><td>";
if ( $this->ErrMsg ) $form .= "<marquee>".$this->ErrMsg."</marquee>" ;
$form .= "</td><td width=86 height=29><input type=image src='"._HOMEPAGE."OO/form_bval.gif'></td></tr></table>";
}
$form .= "</form>";
return $form;
}// end show
function test( ){
$test = true;
for ($i=1;$i< $this->numfields ; $i++){
$this->fieldErrMsg[$i] = eval ($this->test[$i]);
if ( $this->fieldErrMsg[$i] != "" ) $test = false;
}
return $test;
}//end test
function fillAutoField(){
foreach ($this->rows as $key => $row) {
if ($row->auto){
switch($row->auto){
case 'nextSequence':
$temp = '$temp = $this->nextSequence("'.$key.'");';
eval($temp);
$this->rows[$key]->fieldValue = $temp;
break;

}
}
}
}//end fillAutoField
function getSQLSyntax(){
$rtn = "";
$into = "";
$values = "";
$set = "";
$where = "";
foreach ($this->rows as $key => $row) {
if ($row->key){
$where .= ($where == "" )? "" :" and ";
$where .= $key."=".$row->toDB()." ";
}else{
$set = "";
}
$into .= ','.$key;
$values .= ','.$row->toDB();
}
//retirer la premiere ','
$into = substr($into,1);
$values = substr($values,1);

switch ($this->mode){
case MODIFY:
$rtn = "update ".$this->table." set ".$set." where ".$where.";";
break;
case ADD:
$rtn = "insert into ".$this->table."(".$into.") values(".$values.");";
break;
}
return $rtn;
}//end getSQLSyntax
function sql_exec($SQL ){
return false; //abstract
}
function commit( ){
$this->fillAutoField();
$SQL = $this->getSQLSyntax();

if ($this->sql_exec($SQL)){
switch ($this->mode){
case MODIFY:
$this->ErrMsg = "<font color=green><b>Enregistrement modifié</b></font>";
break;
case ADD:
$this->ErrMsg = "<font color=green><b>Enregistrement ajouté</b></font>";
break;
}
$this->mode = CONSULT;
}else{
$this->ErrMsg = "<font color=red><b>Modification annulée</b></font>";
}
}//end commit
}//end class
?>

et voici une page qui utilise ces classes.

<? session_start();
include "../OO/page.inc";//la mise en page
include "../OO/formms.inc";
$mode = (isset($_GET['mode']))? $_GET['mode']:CONSULT;
$body = "<img src='../Accueil/helpdesk.jpg' >";

$SQL = "select ...mes champs... from Matable ";
if ($mode == ADD){
$SQL .= " where 1 = -1";
$body .="<b> Ajout d'un trackit </b><br />";
}else{
$SQL .= " where XX_NUM = ".$_GET['num'];
$body .="<b> Détail du trackit ".$_GET['num']."</b><br />";
}
$obj_form = new formms($SQL); //Création du formulaire
$obj_form->mode($mode);

$traduction = array ( "XX_NUM"=>"N° appel: ", "brol"=>"Récapitulatif: ", ... "NOTE"=>"Note: ", "STATUS"=>"Etat: " );
$obj_form->traduction($traduction);
$obj_form->primary("XXID");
$obj_form->setAuto("XX_NUM","nextSequence");
if ( $obj_form->test() && count($_POST)>0) $obj_form->commit();
$body .= $obj_form->show();
$page->addhtmlbody($body);
$page->show();
?>

la mise en page depend d'un css, mais il "suffit" d'adapter le fonction ->show() pour modifier la mise en page.
vs pouvez bien entendu signaler des bug ou proposer des améliorations.
a venir : la possibilité de proposer une liste de choix pour un champs(option select)

**Mr N.** · 13/02/2006, 17h34

plutot que la couleur, je préfère l'indentation grâce aux balises [code]

**titoumimi** · 14/02/2006, 09h44

Suite à de nombreuses demandes sur le forum, voici un petit script de lecture / écriture de fichier. Ici, nous ouvrons un fichier distant, en lisons le contenu, et l'enregistrons en local.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
<?php
    // ---------------- Ouverture et lecture du fichier distant ----------------
    //Ouverture du fichier $fichier
    $fichier = "http://www.google.fr/intl/fr_fr/images/logo.gif";
    $fichierouvert = fopen ($fichier, "r");
    // Initialisation de la variable contenu
    $contenu ="";
    //Mise en mémoire du fichier dans une variable $contenu
    while (!feof($fichierouvert)) {
      $contenu .= fread($fichierouvert, 8192);
    }
    fclose ($fichierouvert);
 
    // ---------------- Création et écriture du fichier local ----------------
    //Répertoire de destination
    $dirname = "";  
    // Fichier de destination
    $filename = "carte.gif";
    //Ouverture du répertoire de destination
    $fichierouvert = fopen ($dirname.$filename, "w+");
    //Copie du fichier
    if ( !fwrite($fichierouvert, $contenu)) {
      echo "Impossible d'écrire dans le fichier ($filename)";
      exit;
    }
    //Fermeture du fichier
    fclose ($fichierouvert);
?>

Au moment de la lecture du fichier, on pourrait simplifier en remplacant le while par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
$contenu = fread ($fichier_ouvert, filesize($filename));

mais il semble que la propriété filesize ne soit pas accessible à chaque fois.

Pour la création et l'écriture dans un fichier, pensez bien à vérifier que vous avez les droits requis dans le répertoire donné et sur le fichier.

Pour les modes d'ouverture du fichier, faites bien attention :

'r' Ouvre en lecture seule, et place le pointeur de fichier au début du fichier.
'r+' Ouvre en lecture et écriture, et place le pointeur de fichier au début du fichier.
'w' Ouvre en écriture seule ; place le pointeur de fichier au début du fichier et réduit la taille du fichier à 0. Si le fichier n'existe pas, on tente de le créer.
'w+' Ouvre en lecture et écriture ; place le pointeur de fichier au début du fichier et réduit la taille du fichier à 0. Si le fichier n'existe pas, on tente de le créer.
'a' Ouvre en écriture seule ; place le pointeur de fichier à la fin du fichier. Si le fichier n'existe pas, on tente de le créer.
'a+' Ouvre en lecture et écriture ; place le pointeur de fichier à la fin du fichier. Si le fichier n'existe pas, on tente de le créer.
'x' Crée et ouvre le fichier en lecture seule ; place le pointeur de fichier au début du fichier. Si le fichier existe déjà, fopen() va échouer, en retournant FALSE et en générant une erreur de niveau E_WARNING. Si le fichier n'existe pas, fopen() tente de le créer. Ce mode est l'équivalent des options O_EXCL|O_CREAT pour l'appel système open(2) sous-jacent. Cette option est supportée à partir de PHP 4.3.2 et fonctionne uniquement avec des fichiers locaux.
'x+' Crée et ouvre le fichier en lecture et écriture ; place le pointeur de fichier au début du fichier. Si le fichier existe déjà, fopen() va échouer, en retournant FALSE et en générant une erreur de niveau E_WARNING. Si le fichier n'existe pas, fopen() tente de le créer. Ce mode est l'équivalent des options O_EXCL|O_CREAT pour l'appel système open(2) sous-jacent. Cette option est supportée à partir de PHP 4.3.2, et fonctionne uniquement avec des fichiers locaux.

**Canard0** · 17/02/2006, 15h00

Charger dans une variable le contenu d'une page protégée par un login

Ce script est spécialement utile pour faire de l'extraction de données dans un site nécéssitant un login.

Le script est assez court, mais la difficulté résidait dans la création du contexte correct pour faire transiter les informations de login en POST et le maintien du numéro de session.

Pour illustrer le fonctionnement, voici le script sécurisé ( supposé être dans l'alias de dossier de publication http://localhost/php/ et s'appeler main.php ):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?
   session_start();
   if ($_POST[user]=="Moi" && $_POST[pass]=="AJE")
   {
     $_SESSION[accept]="OK";
     echo "Enregistrement ok.<br><a href='main.php'>Contenu</a>";
   }
   else if ($_SESSION[accept]=="OK")
   {
     echo "BRAVO. Vous avez accédé au contenu";
   }
   else
   {
     echo '<form name="mainform" method="post">';
     echo 'User:<input type="text" name="user" value="Moi" size="20" /><br>';
     echo 'Pass:<input type="password" name="pass" value="AJE" size="20" /><br>';
     echo '<input type="submit" name="Envoi" /></form>';
   }
?>

et voici la solution:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
// Référence pour les contextes http://fr.php.net/stream
$opts = array ('http'=>array ('method' => 'POST',
                              'content'=> 'user=Moi&pass=AJE',
                              'header' => "Accept-language: en\r\n".
                                          "Cookie: PHPSESSID=9d5c2d1c8cfab4094283887a2623a0c4" )
              );
$context = stream_context_create($opts);
$fichier = fopen('http://localhost/php/main.php', 'r', false, $context);
fclose($fichier);
$opts = array ('http'=>array ('method' => 'GET',
                              'header' => "Accept-language: en\r\n".
                                          "Cookie: PHPSESSID=9d5c2d1c8cfab4094283887a2623a0c4" )
              );
$context = stream_context_create($opts);
$fichier = fopen('http://localhost/php/main.php', 'r', false, $context);
while ($str=fread($fichier, 16))
{
  $src .="$str";
}
fclose($fichier);
echo $src;
?>

Je n'en suis pas peu fier, j'ai dû bien chercher...

Que le code soit avec toi.

**zulot** · 22/02/2006, 20h09

alors moi je vais porter ma ptite pierre toute toute petite à l'édifice

On veut souvent vérifier dans un forulaire qu'un mail est bien correcte, un '.' et un '@ et sans ';' en geral donc voila une ptite focntion pour ca

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
//Verifier la presence de caractere interdit dans une chaine pour un mail 
function falsemail($email){  
if( strpos($email,'.') === false || strpos($email,'@') == false || strpos($email,';') == true )  
 
return(true); 
 
else 
 
 
return(false); 
}

Sinon j'ai voulu changer la fonction pour n'importe quel chaine et avec n'importe quel type de caractere a interdir, en gros un tableau de caractere interdit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
// verifie la presence de caractere interdit (variable $tab) pour une chaine 
function falsechaine($chaine,$tab){  
$ereur = false; 
 
for($i=0;$i<sizeof($tab) && $ereur == false;$i++){  
 
if( strpos($chaine,$tab[$i]) != false )  
 
 
$ereur = true;
 
 
} 
 
return($ereur); 
}

voila j'espere ca en aidera certains

/!\ En faisant des test plus poussé je viens de m'apercevoir d'un bug.
Si le caractere interdit se trouve en 1ere position il n'est pas detexté!!!! donc rajouté un espace dans la variable de chaine a tester en tout debut ce qui permet d'éviter ce bug.

**Anduriel** · 23/02/2006, 21h30

Class d'upload

Cette classe permet de charger (normalement) simplement un ou des fichiers sur un serveur distant ou local, supprimer, créer des dossiers.
Je l'ai faite sans trop l'utiliser mais ça peut servir

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
<?php
/****************************************************/
/*  Class FileManager par Krak @ Anduriel
****************************************************/
 
define ("FTP_CONNECTSSL_FAILED", "<b>Erreur critique:</b> connection au serveur 
impossible. Vérifiez si l' OpenSSL est installé.");
define ("FTP_CONNECT_FAILED", "<b>Erreur critique:</b> connection au serveur imp
ossible.");
define ("LOGIN_FAILED", "<b>Erreur critique:</b> impossible de se connecter, vér
ifiez les paramètres d'accès.");
define ("NO_FILE_UPLOADED", "<b>Erreur:</b> le fichier n'a pas été téléchargé su
r le serveur.");
define ("ERR_FILESIZEINI", "<b>Erreur:</b> la taille d'un des fichiers dépasse l
a limite fixée dans votre php.ini.");
define ("ERR_FILESIZE", "<b>Erreur:</b> la taille d'un des fichiers dépasse la l
imite fixé par le formulaire.");
define ("ERR_PARTIALDL", "<b>Erreur:</b> un des fichiers a été téléchargé partie
llement dans le dossier temporaire.");
define ("ERR_NOFILEDL", "<b>Erreur:</b> un des fichiers n'a pas été téléchargé d
ans le dossier temporaire");
define ("ERR_NOFOLDER", "<b>Erreur:</b> dossier temporaire introuvable.");
define ("ERR_CANTWRITE", "<b>Erreur:</b> impossible d'écrire le fichier dans le 
dossier temporaire.");
define ("CANT_CHANGEDIR", "<b>Erreur:</b> impossible d'entrer dans le dossier ")
;
define ("CANT_CREATEDIR", "<b>Erreur:</b> impossible de créer le dossier demandé
.");
define ("SSL_NOTINSTALLED", "<b>Erreur:</b> l'ouverture sécurisée SSL n'est pas 
disponible.");
define ("CANT_DELETEFILE", "<b>Erreur:</b> impossible de supprimer le fichier sp
écifié.");
define ("INVALID_FILE", "<b>Erreur:</b> fichier spécifié invalide ou introuvable
.");
define ("NO_DELETE", "<b>Erreur:</b> fichier non supprimé. Il se peut qu'aucun d
ossier n'ait été spécifié.");
define ("CANT_CHMOD", "<b>Erreur:</b> impossible de changer le chmod du dossier/
fichier spécifié.");
define ("CANT_RENAME", "<b>Erreur:</b> impossible de changer le nom du dossier s
pécifié.");
define ("CANT_LIST", "<b>Erreur:</b> impossible de lister le répertoire.");
 
class FileManager {
   var $envars;
   var $openftp;
   var $file_destination = '.';
   var $force;
 
  /***************************************************************
*********/
  /* Function d'enregistrement des variables
  /* setftpvars(urlserver, accessname, acesspass [, mode])
  /*  - urlserver = url du ftp sans www et sans slasch (ftpperso.free.fr)
  /*  - accessname = pseudo de connection
  /*  - accessspass = mot de passe de connection
  /*  - mode = Tranfert des fichiers: ASCII ou BINARY
  /***************************************************************
********/
   function setftpvars($server, $username, $userpass, $mode="ASCII") {
      $this->envars['ftp_server'] = $server;
      $this->envars['ftp_pass'] = $userpass;
      $this->envars['ftp_login'] = $username;
      $this->envars['ftp_transfert'] = constant('FTP_'.$mode);
   }
  /***************************************************************
*********/
  /* Se place dans un dossier spécifique
  /* setftpdir(dir, force)
  /*  - dir = dossier dans lequel charger les fichiers
  /*  - force = crée le dossier s'il est inexistant
  /***************************************************************
********/
   function setftpdir($dir, $force=false) {
      $this->file_destination = $dir;
      $this->force = $force;
   }
  /***************************************************************
*********/
  /* Créé un dossier
  /* createdir(dir [, chmod] [, dest])
  /*  - dir = dossier à crée
  /*  - chmod = droit d'accès au dossier. Par défaut 0777
  /*  - dest = true pour créer sur un serveur distant
  /***************************************************************
********/
   function createdir($dir, $chmod=0777, $dest=false) {
      if (!is_dir($dir) && $dest == false) {
         @mkdir($dir, $chmod) or die (CANT_CREATDIR);
      }
     elseif (!is_dir($dir) && $dest != false) {
         @ftp_mkdir($this->openftp, $dir) or die (CANT_CREATDIR);
      }
   }
  /***************************************************************
*********/
  /* Function de connection à un serveur distant
  /* opensslftp(openmode)
  /*  - openmode = true pour une ouverture sécurisée SSL
  /***************************************************************
********/   
   function openftp($sslopen=false) {
      if ($sslopen == true) {
         if (!function_exists("ftp_ssl_connect")) {
            echo SSL_NOTINSTALLED;
            exit;
         }
         if (!$this->openftp = @ftp_ssl_connect($this->envars['ftp_server'])) {
            echo FTP_CONNECTSSL_FAILED;
            exit;
         }
      } else {
         if (!$this->openftp = @ftp_connect($this->envars['ftp_server'])) {
            echo FTP_CONNECT_FAILED;
            exit;
         }
      }
      @ftp_login($this->openftp, $this->envars['ftp_login'], $this->envars['ftp_
pass']) or die (LOGIN_FAILED);
   }
  /***************************************************************
*********/
  /* Charge les fichiers issus d'un formulaire
  /* uploadfiles(input, destination)
  /*  - input = nom du champ de type file. Il peut être un tableau.
  /*  - destination = true pour les charger sur un serveur distant
  /***************************************************************
********/     
   function uploadfiles($inputname="", $specialftp="") {
      if (!empty($_FILES[$inputname])) {
         foreach($_FILES[$inputname]['name'] As $key => $file) {
            if ($file != '') {
               $lastfile = ' (Fichier concerné: <b>'.htmlspecialchars($file).'</
b>)<br>';
               switch($_FILES[$inputname]['error'][$key]) {
                  case 1:
                     echo ERR_FILESIZEINI.$lastfile;
                     exit;
              case 2:
                    echo ERR_FILESIZE.$lastfile;
                    exit;
                  case 3:
                     echo ERR_PARTIALDL.$lastfile;
                     exit;
                  case 4:
                     echo ERR_NOFILEDL.$lastfile;
                     exit;
                  case 6:
                     echo ERR_NOFOLDER.$lastfile;
                     exit;
                  case 7:
                     echo ERR_CANTWRITE.$lastfile;
                     exit;
                  default: break;
               }
               $filename = basename($_FILES[$inputname]['name'][$key]);
               if (empty($specialftp)) {
                  if ($this->force == true) $this->createdir($this->file_destina
tion);
                  if (!$is_moved = @move_uploaded_file($_FILES[$inputname]['tmp_
name'][$key], $this->file_destination.'/'.$filename)) {
                     echo NO_FILE_UPLOADED.$lastfile;
                  }
               } else {
                  $fp = fopen($_FILES[$inputname]['tmp_name'][$key], 'r');
                  if ($this->force == true) $this->createdir($this->file_destina
tion, 0777, true);
                  @ftp_chdir($this->openftp, $this->file_destination) or die(CAN
T_CHANGEDIR.$this->file_destination);
                  if (!$is_moved = @ftp_fput($this->openftp, $filename, $fp, $th
is->envars['ftp_transfert'])) {
                     echo NO_FILE_UPLOADED.$lastfile;
                  }
                  else {
                     fclose($fp);
                  }
               }
            }
         }
      }
   }
  /***************************************************************
*********/
  /* Supprime un fichier ou des fichiers
  /* deletetfile(file [, destination]])
  /*  - file = fichier à supprimer. Pour plusieurs fichiers metter un tableau
  /*    Ce fichier sera supprimé du dossier setftpdir() si le dossier n'est pas 
spécifié
  /*    dans un tableau:
  /*    => array('file1.txt' => 'dir/dir', 'file2.exe' => '../dir2', 'file3.html
')
  /*  - destination = true pour les supprimer d'un serveur distant
  /***************************************************************
********/
   function deletefile($file, $specialftp="") {
      $lastfile = (!is_array($file)) ? ' (Fichier concerné: <b>'.htmlspecialchar
s($file).'</b>)<br>' : ' (Tableau de fichier)';
  if (!is_array($file) && is_file($this->file_destination.'/'.$file)) {
     if (empty($specialftp)) {
        return @unlink($this->file_destination.'/'.$file) or die (CANT_DELETEFIL
E.$lastfile);
     } else {
        return @ftp_delete($this->openftp, $this->file_destination.'/'.$file) or
 die (CANT_DELETEFILE.$lastfile);
     }
  }
  elseif (is_array($file)) {
     foreach($file as $dir => $to_delete) {
        $lastfile = ' (Fichier concerné: <b>'.htmlspecialchars($to_delete).'</b>
)<br>';
        $dir = (is_numeric($dir)) ? $this->file_destination : $dir;
        if (is_file($dir.'/'.$to_delete)) {
           if (empty($specialftp)) {
              @unlink($dir.'/'.$to_delete) or die (CANT_DELETEFILE.$lastfile);
           } else {
              @ftp_delete($this->openftp, $dir.'/'.$to_delete) or die (CANT_DELE
TEFILE.$lastfile);
           }
        } else {
           echo INVALID_FILE.$lastfile;
        }
     }
  }
  else {
     echo NO_DELETE.$lastfile;
  }
   }
  /***************************************************************
*********/
  /* Change le Chmod d'un dossier ou d'un fichier
  /* changechmoddir(dir, chmod, destination)
  /*  - dir = dossier dont le chmod est à modifier
  /*  - chmod = droit d'accès au dossier.
  /*  - destination = true si le fichier ou dossier est sur un serveur distant
  /***************************************************************
********/
   function changechmod($filedir, $chmod, $specialftp="") {
      if (empty($specialftp)) {
         @chmod($filedir, $chmod) or die (CANT_CHMOD);
      }
      else {
         @ftp_chmod($this->openftp, $filedir, $chmod) or die (CANT_CHMOD);
      }
   }
  /***************************************************************
*********/
  /* Renomme un dossier/fichier
  /* changenamedir(dirfile, newname, destination)
  /*  - dirfile = dossier/fichier dont le nm est à modifier
  /*  - newname = nouveau nom
  /*  - destination = true si le fichier ou dossier est sur un serveur distant
  /***************************************************************
********/
   function changename($dirfile, $name, $specialftp="") {
      if (empty($specialftp)) {
         @rename($dirfile, $name) or die (CANT_RENAME);
      }
      else {
         @ftp_rename($this->openftp, $dirfile, $name) or die (CANT_RENAME);
      }
   }
  /***************************************************************
*********/
  /* Liste un répertoire
  /* listrepertory(repertory, destination)
  /*  - destination = true si le dossier est sur un serveur distant
  /***************************************************************
********/
   function listrepertory($repertory, $specialftp="") {
      if (empty($specialftp)) {
         if ($handle = @opendir($repertory)) {
            while (false !== ($file = @readdir($handle))) {
               if ($file != "." && $file != "..") {
                  if (is_file($file)) $prefix = ' (fichier)';
                  if (is_dir($file)) $prefix = ' (dossier)';
                  echo '- '.$file.$prefix.'<br>';
               }
           }
         closedir($handle);
         } else echo CANT_LIST;
      }
      else {
         $contents = ftp_nlist($this->openftp, '.');
         var_dump($contents);
         foreach ($contents AS $file) {
            if (is_file($file)) $prefix = 'Type: fichier, nom: ';
            if (is_dir($file)) $prefix = 'Type: dossier, nom: ';
            echo $prefix.$file.'<br>';
         }
      }
   }
}

Vos meilleurs codes sources

Contribuez / Téléchargez Sources et Outils PHP

Vue hybride

Discussions similaires

Partager

Partager