home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 August / PCWorld_2001-08_cd.bin / Komunikace / phptriad / phptriadsetup2-11.exe / htdocs / showoff.php3 < prev    next >
Encoding:
Text File  |  2000-03-23  |  7.8 KB  |  200 lines
  1. <?php 
  2. // I use auto_prepend= in my php3.ini file to have 
  3. // prepend.php3 in front of this file. If you don't
  4. // want to use this feature you have to include it
  5. // manually:
  6.  
  7. // include("prepend.php3");
  8.  
  9. // You will have to set up your include_path= in
  10. // php3.ini to make this work, though.
  11.  
  12.  
  13. // This is here to test the features of the Table class
  14.   include($_PHPLIB["libdir"] . "table.inc");
  15.  
  16. // We use the following features:
  17. //  sess   for session variables
  18. //  auth   for login checks, also required for user variables
  19. //  perm   for permission checks
  20. //  user   for user variables
  21.   page_open(array("sess" => "Example_Session", "auth" => "Example_Auth", "perm" => "Example_Perm", "user" => "Example_User"));
  22.  
  23.   // page access requires that the user is authenticated and has "admin" permission
  24.   $perm->check("admin");
  25.   
  26.   // s is a per session variable, u is a per user variable.
  27.  
  28.   //  If they've already been loaded in from the database, leave them alone
  29.   //  Otherwise, set them to a value so we don't get PHP warnings later.
  30.   if(!isset($s)) { $s=0; };
  31.   if(!isset($u)) { $u=0; };
  32.  
  33.   $sess->register("s");
  34.   $user->register("u");
  35.  
  36. ?>
  37. <html>
  38. <head>
  39. <!-- Style sheet used by Table class below -->
  40. <style type="text/css">
  41. table.metadata { background-color: #eeeeee; border-width: 0; padding: 4 }
  42. th.metadata    { font-family: arial, helvetica, sans-serif }
  43. td.metadata    { font-family: arial, helvetica, sans-serif }
  44. table.data     { background-color: #cccccc; border-width: 0; padding: 4 }
  45. th.data        { font-family: arial, helvetica, sans-serif; horizontal-align: left; vertical-align: top }
  46. td.data        { font-family: arial, helvetica, sans-serif; horizontal-align: left; vertical-align: top }
  47. </style>
  48. </head>
  49. <body bgcolor="#ffffff">
  50.  
  51.   <a href="<?php $sess->pself_url()?>">Reload</a> this page to see the counters increment.<br>
  52.   <a href="<?php $sess->purl("index.php3") ?>">Load</a> the simple page again.<br>
  53.   <a href="<?php $sess->purl("defauth.php3") ?>">Load</a> the default auth example.<br>
  54.   <a href="<?php $sess->purl("test.php3") ?>">Show</a> your phpinfo() page.<br>
  55.   <a href="<?php $sess->purl("logout.php3") ?>">Logout</a> and delete your authentication information.<br>
  56.  
  57. <?php
  58.   // Demonstration of per session data: We are incrementing a scalar, $s.
  59.   printf("<h1>Per Session Data: %s</h1>\n", ++$s);
  60. ?>
  61.  
  62.   Per Session Data is referenced by session id. The session id is propagated
  63.   using either a cookie stored in the users browser or as a GET style
  64.   parameter appended to the current URL.
  65.   <p>
  66.   Per Session Data is available only on pages using the feature
  67.   "sess" in their page_open() call.
  68.  
  69. <?php
  70.   // Demonstration of per user data: We are incrementing a scalar, $u.
  71.   printf("<h1>Per User Data: %s</h1>\n", ++$u);
  72. ?>
  73.  
  74.   Per User Data is referenced by user id. The user id is stored as a session
  75.   variable in each authenticated session.
  76.   <p>
  77.  
  78.   Per User Data is only available on authenticated pages (pages using the
  79.   feature "auth" in addition to the feature "sess"). It
  80.   is activated with by using the feature "user".
  81.  
  82. <h2>Some interesting variables</h2>
  83.  
  84. <?php
  85.   // Show how to access the session and the user id.
  86.   printf("Your session id is %s<br>\n", $sess->id);
  87.   printf("Your user id is %s<br>\n", $user->id);
  88.   printf("This should be the same as %s<br>\n", $auth->auth["uid"]);
  89.   printf("You have the permissions %s<br>\n", $auth->auth["perm"]);
  90. ?>
  91. <h2>Table class test</h2>
  92.  
  93. <?php
  94.  
  95.   // Grab a description of "active_sessions" as an array $tab.
  96.   $db = new DB_Example;
  97.   $tab = $db->metadata("active_sessions");
  98.  
  99.   // Create a Table instance to print that array
  100.   $t          = new Table;
  101.   $t->heading = "on";
  102.   // Dump that array as a HTML table, using the style sheet class "metadata".
  103.   printf("<h3>active_sessions metadata</h3>\n");
  104.   $t->show($tab, "metadata");
  105. ?>
  106.  
  107. The <b>active_sessions</b> table holds all persistent data for a session, a
  108. user or an application. This is a dump of the structure of that table.
  109. <p>
  110.  
  111. The <b>name</b> is an identifier for a namespace. Usually it is the name of
  112. the class that creates ids. For example, <tt>Example_Session</tt> is the name of
  113. the class managing session variables in this example and <tt>Example_User</tt>
  114. is the name of the class managing user variables in this example.
  115. <p>
  116.  
  117. The <b>sid</b> is a unique identifier within a namespace. Both,
  118. <tt>name</tt> and <tt>sid</tt> together can be used as a key into the
  119. <tt>active_sessions</tt> table. The identifier should be hard to guess and
  120. not predictable. That is why we use 32 character md5() strings of values
  121. created by uniqid().
  122. <p>
  123.  
  124. The <b>val</b> is where the data associated with a
  125. <tt>name</tt>/<tt>sid</tt> pair is stored. Data is stored in the form of a
  126. PHP program that recreates the values stored. The string retrieved from
  127. <tt>val</tt> is later fed to exec() in PHP. Since <tt>val</tt> can become a
  128. pretty large string, we use a <i>blob</i> or a similar large datatype to
  129. store it.
  130. <p>
  131.  
  132. The <b>changed</b> value indicates when the last write into that particular
  133. row of the table has occured. It is used by the gc() functions (garbage
  134. collection functions) of their respective owner classes. The gc() of a class
  135. will delete all rows belonging to that class (<tt>name</tt> is being
  136. checked) that have not been written to for a given number of minutes. The
  137. gc() is called randomly with an adjustable probability.
  138.  
  139. <?php
  140.  
  141.   // Again, but this time the table contents.
  142.   // This time, the style sheet class "data" is being used.
  143.   $db->query("select * from active_sessions order by changed desc");
  144.   
  145.   // $t is reused...
  146.   printf("<h3>active_sessions data</h3>\n");
  147.   
  148.   printf("Only the newest ten session entries are shown:<br>\n");
  149.   $t->show_result_page($db,  0, 10, "data");
  150.   printf("Ten more entries are shown (if present):<br>\n");
  151.   $t->show_result_page($db, 10, 10, "data");
  152.   printf("End of your active_sessions data<br>\n");
  153. ?>
  154.  
  155. The <b>active_sessions</b> table holds all persistent data for a
  156. session, a user or an application. This is a dump of the
  157. contents of that table. <p>
  158.  
  159. You will find two different types of entries in this table,
  160. distinguished by the value in the <b>name</b> column.
  161. <tt>Example_Session</tt> entries belong to per session data.
  162. <tt>Example_User</tt> entries belong to per user data. The actual
  163. data is visible in the <b>val</b> column.
  164. <p>
  165.  
  166. Within that <tt>val</tt> column you find an executeable PHP
  167. program. This programs contains assignments only. You will find
  168. two types of assignments: Assignments to internal class
  169. variables (<tt>$this->pt</tt> assignments) and assignments to
  170. global variables (<tt>$GLOBALS</tt> assignments).
  171. <p>
  172.  
  173. Assignments to internal class variables are used by the saving
  174. class itself so that it can remember which variables are to be
  175. saved. These assignments record the names of all global
  176. variables that are to be saved by that class. For example, if
  177. there is a <tt>Example_Session</tt> that contains the statements
  178. <tt>$this->pt["auth"] = 1;
  179. $this->pt["s"] = 1</tt>, you can see that the
  180. global variables <tt>$auth</tt> and <tt>$s</tt> are per session
  181. variables.
  182. <p>
  183.  
  184. Later in that string you will find other assignments to
  185. <tt>$GLOBALS["s""]</tt> that store the current
  186. value of <tt>$s</tt>. Since <tt>$s</tt> is a scalar variable in
  187. this example, you will find only a simple assignment.
  188. <p>
  189.  
  190. You will also find a lot of assignments to
  191. <tt>$GLOBALS["auth"]</tt>. Since <tt>$auth</tt> is an
  192. object, it cannot be reconstructed with a single assignment, but
  193. needs multiple instructions to reconstruct the full objects.
  194. <p>
  195.  
  196. </body>
  197. </html>
  198. <?php page_close() ?>
  199. <!-- $Id: showoff.php3,v 1.7 1999/10/14 10:38:21 kk Exp $ -->
  200.