?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

b4f30171032ec7ab76476b4696d25f364690103b
[openemr.git] / gacl / gacl.class.php
blobb4f30171032ec7ab76476b4696d25f364690103b
1 <?php
2 // $Id$
3
4 /**
5 * phpGACL - Generic Access Control List
6 * Copyright (C) 2002,2003 Mike Benoit
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * For questions, help, comments, discussion, etc., please join the
23 * phpGACL mailing list. http://sourceforge.net/mail/?group_id=57103
24 *
25 * You may contact the author of phpGACL by e-mail at:
26 * ipso@snappymail.ca
27 *
28 * The latest version of phpGACL can be obtained from:
29 * http://phpgacl.sourceforge.net/
30 *
31 * @package phpGACL
32 */
33
34 /*
35 * Path to ADODB.
36 */
37 if ( !defined('ADODB_DIR') ) {
38 define('ADODB_DIR', dirname(__FILE__).'/adodb');
39 }
40
41 //openemr configuration file - bm - 05-2009
42 // to collect sql database login info and the utf8 flag
43 include_once(dirname(__FILE__).'/../library/sqlconf.php');
44
45 /**
46 * phpGACL main class
47 *
48 * Class gacl should be used in applications where only querying the phpGACL
49 * database is required.
50 *
51 * @package phpGACL
52 * @author Mike Benoit <ipso@snappymail.ca>
53 */
54 class gacl {
55 /*
56 --- phpGACL Configuration path/file ---
57 */
58 var $config_file = '';
59
60 /*
61 --- Private properties ---
62 */
63 /** @var boolean Enables Debug output if true */
64 var $_debug = FALSE;
65
66 /*
67 --- Database configuration. ---
68 */
69 /** @var string Prefix for all the phpgacl tables in the database */
70 var $_db_table_prefix = 'gacl_';
71
72 /** @var string The database type, based on available ADODB connectors - mysql, postgres7, sybase, oci8po See here for more: http://php.weblogs.com/adodb_manual#driverguide */
73 var $_db_type = 'mysql';
74
75 /** @var string The database server */
76 var $_db_host = '';
77
78 /** @var string The database user name */
79 var $_db_user = '';
80
81 /** @var string The database user password */
82 var $_db_password = '';
83
84 /** @var string The database name */
85 var $_db_name = '';
86
87 /** @var object An ADODB database connector object */
88 var $_db = '';
89
90 /** @var boolean The utf8 encoding flag - bm 05-2009 */
91 var $_db_utf8_flag = '';
92
93 /*
94 * NOTE: This cache must be manually cleaned each time ACL's are modified.
95 * Alternatively you could wait for the cache to expire.
96 */
97
98 /** @var boolean Caches queries if true */
99 var $_caching = FALSE;
100
101 /** @var boolean Force cache to expire */
102 var $_force_cache_expire = TRUE;
103
104 /** @var string The directory for cache file to eb written (ensure write permission are set) */
105 var $_cache_dir = '/tmp/phpgacl_cache'; // NO trailing slash
106
107 /** @var int The time for the cache to expire in seconds - 600 == Ten Minutes */
108 var $_cache_expire_time=600;
109
110 /** @var string A switch to put acl_check into '_group_' mode */
111 var $_group_switch = '_group_';
112
113 /**
114 * Constructor
115 * @param array An arry of options to oeverride the class defaults
116 */
117 function gacl($options = NULL) {
118
119 $available_options = array('db','debug','items_per_page','max_select_box_items','max_search_return_items','db_table_prefix','db_type','db_host','db_user','db_password','db_name','caching','force_cache_expire','cache_dir','cache_expire_time');
120
121 //Values supplied in $options array overwrite those in the config file.
122 if ( file_exists($this->config_file) ) {
123 $config = parse_ini_file($this->config_file);
124
125 if ( is_array($config) ) {
126 $gacl_options = array_merge($config, $options);
127 }
128
129 unset($config);
130 }
131
132 if (is_array($options)) {
133 foreach ($options as $key => $value) {
134 $this->debug_text("Option: $key");
135
136 if (in_array($key, $available_options) ) {
137 $this->debug_text("Valid Config options: $key");
138 $property = '_'.$key;
139 $this->$property = $value;
140 } else {
141 $this->debug_text("ERROR: Config option: $key is not a valid option");
142 }
143 }
144 }
145
146 //collect openemr sql info from include at top of script - bm 05-2009
147 global $sqlconf, $disable_utf8_flag;
148 $this->_db_host = $sqlconf["host"];
149 $this->_db_user = $sqlconf["login"];
150 $this->_db_password = $sqlconf["pass"];
151 $this->_db_name = $sqlconf["dbase"];
152 if (!$disable_utf8_flag) {
153 $utf8_flag = true;
154 }
155 else {
156 $utf8_flag = false;
157 }
158 $this->_db_utf8_flag = $utf8_flag;
159
160 require_once( ADODB_DIR .'/adodb.inc.php');
161 require_once( ADODB_DIR .'/adodb-pager.inc.php');
162
163 if (is_object($this->_db)) {
164 $this->db = &$this->_db;
165 } else {
166 $this->db = ADONewConnection($this->_db_type);
167 //Use NUM for slight performance/memory reasons.
168 $this->db->SetFetchMode(ADODB_FETCH_NUM);
169 $this->db->PConnect($this->_db_host, $this->_db_user, $this->_db_password, $this->_db_name);
170
171 // Modified 5/2009 by BM for UTF-8 project
172 if ($this->_db_utf8_flag) {
173 $success_flag = $this->db->Execute("SET NAMES 'utf8'");
174 if (!$success_flag) {
175 error_log("PHP custom error: from gacl gacl/gacl.class.php - Unable to set up UTF8 encoding with mysql database".$this->db->ErrorMsg(), 0);
176 }
177 }
178 // ---------------------------------------
179
180 }
181 $this->db->debug = $this->_debug;
182
183 if ( $this->_caching == TRUE ) {
184 if (!class_exists('Hashed_Cache_Lite')) {
185 require_once(dirname(__FILE__) .'/Cache_Lite/Hashed_Cache_Lite.php');
186 }
187
188 /*
189 * Cache options. We default to the highest performance. If you run in to cache corruption problems,
190 * Change all the 'false' to 'true', this will slow things down slightly however.
191 */
192
193 $cache_options = array(
194 'caching' => $this->_caching,
195 'cacheDir' => $this->_cache_dir.'/',
196 'lifeTime' => $this->_cache_expire_time,
197 'fileLocking' => TRUE,
198 'writeControl' => FALSE,
199 'readControl' => FALSE,
200 'memoryCaching' => TRUE,
201 'automaticSerialization' => FALSE
202 );
203 $this->Cache_Lite = new Hashed_Cache_Lite($cache_options);
204 }
205
206 return true;
207 }
208
209 /**
210 * Prints debug text if debug is enabled.
211 * @param string THe text to output
212 * @return boolean Always returns true
213 */
214 function debug_text($text) {
215
216 if ($this->_debug) {
217 echo "$text<br>\n";
218 }
219
220 return true;
221 }
222
223 /**
224 * Prints database debug text if debug is enabled.
225 * @param string The name of the function calling this method
226 * @return string Returns an error message
227 */
228 function debug_db($function_name = '') {
229 if ($function_name != '') {
230 $function_name .= ' (): ';
231 }
232
233 return $this->debug_text ($function_name .'database error: '. $this->db->ErrorMsg() .' ('. $this->db->ErrorNo() .')');
234 }
235
236 /**
237 *
238 * Check if the current user has a given type or types of access to an access control object.
239 *
240 * Implemented as a wrapper of acl_query().
241 * This function exists simply to return TRUE/FALSE accordingly.
242 *
243 * @param string $aco_section_value The ACO section value
244 * @param string $aco_value The ACO value
245 * @param string $aro_section_value The ARO section value
246 * @param string $aro_value The ARO value
247 * @param string $axo_section_value The AXO section value (optional)
248 * @param string $axo_value The AXO section value (optional)
249 * @param integer $root_aro_group The group id of the ARO (optional)
250 * @param integer $root_axo_group The group id of the AXO (optional)
251 * @return boolean true if the check succeeds, false if not.
252 */
253 function acl_check($aco_section_value, $aco_value, $aro_section_value, $aro_value, $axo_section_value=NULL, $axo_value=NULL, $root_aro_group=NULL, $root_axo_group=NULL) {
254 $acl_result = $this->acl_query($aco_section_value, $aco_value, $aro_section_value, $aro_value, $axo_section_value, $axo_value, $root_aro_group, $root_axo_group);
255
256 return $acl_result['allow'];
257 }
258
259 /**
260 * Wraps the actual acl_query() function.
261 *
262 * Quick access to the return value of an ACL.
263 * @param string The ACO section value
264 * @param string The ACO value
265 * @param string The ARO section value
266 * @param string The ARO section
267 * @param string The AXO section value (optional)
268 * @param string The AXO section value (optional)
269 * @param integer The group id of the ARO (optional)
270 * @param integer The group id of the AXO (optional)
271 * @return string The return value of the ACL
272 */
273 function acl_return_value($aco_section_value, $aco_value, $aro_section_value, $aro_value, $axo_section_value=NULL, $axo_value=NULL, $root_aro_group=NULL, $root_axo_group=NULL) {
274 $acl_result = $this->acl_query($aco_section_value, $aco_value, $aro_section_value, $aro_value, $axo_section_value, $axo_value, $root_aro_group, $root_axo_group);
275
276 return $acl_result['return_value'];
277 }
278
279 /**
280 * Handles ACL lookups over arrays of AROs
281 * @param string The ACO section value
282 * @param string The ACO value
283 * @param array An named array of arrays, each element in the format aro_section_value=>array(aro_value1,aro_value1,...)
284 * @return mixed The same data format as inputted.
285 \*======================================================================*/
286 function acl_check_array($aco_section_value, $aco_value, $aro_array) {
287 /*
288 Input Array:
289 Section => array(Value, Value, Value),
290 Section => array(Value, Value, Value)
291
292 */
293
294 if (!is_array($aro_array)) {
295 $this->debug_text("acl_query_array(): ARO Array must be passed");
296 return false;
297 }
298
299 foreach($aro_array as $aro_section_value => $aro_value_array) {
300 foreach ($aro_value_array as $aro_value) {
301 $this->debug_text("acl_query_array(): ARO Section Value: $aro_section_value ARO VALUE: $aro_value");
302
303 if( $this->acl_check($aco_section_value, $aco_value, $aro_section_value, $aro_value) ) {
304 $this->debug_text("acl_query_array(): ACL_CHECK True");
305 $retarr[$aro_section_value][] = $aro_value;
306 } else {
307 $this->debug_text("acl_query_array(): ACL_CHECK False");
308 }
309 }
310 }
311
312 return $retarr;
313
314 }
315
316 /**
317 * The Main function that does the actual ACL lookup.
318 *
319 * @param string The ACO section value
320 * @param string The ACO value
321 * @param string The ARO section value
322 * @param string The ARO value
323 * @param string The AXO section value (optional)
324 * @param string The AXO value (optional)
325 * @param string The value of the ARO group (optional)
326 * @param string The value of the AXO group (optional)
327 * @param boolean Debug the operation if true (optional)
328 * @param boolean Option to return all applicable ACL's rather than just one. (optional) (Added by OpenEMR)
329 * @return array Returns as much information as possible about the ACL so other functions can trim it down and omit unwanted data.
330 */
331 function acl_query($aco_section_value, $aco_value, $aro_section_value, $aro_value, $axo_section_value=NULL, $axo_value=NULL, $root_aro_group=NULL, $root_axo_group=NULL, $debug=NULL, $return_all=FALSE) {
332
333 $cache_id = 'acl_query_'.$aco_section_value.'-'.$aco_value.'-'.$aro_section_value.'-'.$aro_value.'-'.$axo_section_value.'-'.$axo_value.'-'.$root_aro_group.'-'.$root_axo_group.'-'.$debug.'-'.$return_all;
334
335 $retarr = $this->get_cache($cache_id);
336
337 if (!$retarr) {
338 /*
339 * Grab all groups mapped to this ARO/AXO
340 */
341 $aro_group_ids = $this->acl_get_groups($aro_section_value, $aro_value, $root_aro_group, 'ARO');
342
343 if (is_array($aro_group_ids) AND !empty($aro_group_ids)) {
344 $sql_aro_group_ids = implode(',', $aro_group_ids);
345 }
346
347 if ($axo_section_value != '' AND $axo_value != '') {
348 $axo_group_ids = $this->acl_get_groups($axo_section_value, $axo_value, $root_axo_group, 'AXO');
349
350 if (is_array($axo_group_ids) AND !empty($axo_group_ids)) {
351 $sql_axo_group_ids = implode(',', $axo_group_ids);
352 }
353 }
354
355 /*
356 * This query is where all the magic happens.
357 * The ordering is very important here, as well very tricky to get correct.
358 * Currently there can be duplicate ACLs, or ones that step on each other toes. In this case, the ACL that was last updated/created
359 * is used; unless the $return_all parameter is set to TRUE, then will return the entire array of applicable ACL information (this
360 * option was added by OpenEMR)
361 *
362 * This is probably where the most optimizations can be made.
363 */
364
365 $order_by = array();
366
367 $query = '
368 SELECT a.id,a.allow,a.return_value
369 FROM '. $this->_db_table_prefix .'acl a
370 LEFT JOIN '. $this->_db_table_prefix .'aco_map ac ON ac.acl_id=a.id';
371
372 if ($aro_section_value != $this->_group_switch) {
373 $query .= '
374 LEFT JOIN '. $this->_db_table_prefix .'aro_map ar ON ar.acl_id=a.id';
375 }
376
377 if ($axo_section_value != $this->_group_switch) {
378 $query .= '
379 LEFT JOIN '. $this->_db_table_prefix .'axo_map ax ON ax.acl_id=a.id';
380 }
381
382 /*
383 * if there are no aro groups, don't bother doing the join.
384 */
385 if (isset($sql_aro_group_ids)) {
386 $query .= '
387 LEFT JOIN '. $this->_db_table_prefix .'aro_groups_map arg ON arg.acl_id=a.id
388 LEFT JOIN '. $this->_db_table_prefix .'aro_groups rg ON rg.id=arg.group_id';
389 }
390
391 // this join is necessary to weed out rules associated with axo groups
392 $query .= '
393 LEFT JOIN '. $this->_db_table_prefix .'axo_groups_map axg ON axg.acl_id=a.id';
394
395 /*
396 * if there are no axo groups, don't bother doing the join.
397 * it is only used to rank by the level of the group.
398 */
399 if (isset($sql_axo_group_ids)) {
400 $query .= '
401 LEFT JOIN '. $this->_db_table_prefix .'axo_groups xg ON xg.id=axg.group_id';
402 }
403
404 //Move the below line to the LEFT JOIN above for PostgreSQL's sake.
405 //AND ac.acl_id=a.id
406 $query .= '
407 WHERE a.enabled=1
408 AND (ac.section_value='. $this->db->quote($aco_section_value) .' AND ac.value='. $this->db->quote($aco_value) .')';
409
410 // if we are querying an aro group
411 if ($aro_section_value == $this->_group_switch) {
412 // if acl_get_groups did not return an array
413 if ( !isset ($sql_aro_group_ids) ) {
414 $this->debug_text ('acl_query(): Invalid ARO Group: '. $aro_value);
415 return FALSE;
416 }
417
418 $query .= '
419 AND rg.id IN ('. $sql_aro_group_ids .')';
420
421 $order_by[] = '(rg.rgt-rg.lft) ASC';
422 } else {
423 $query .= '
424 AND ((ar.section_value='. $this->db->quote($aro_section_value) .' AND ar.value='. $this->db->quote($aro_value) .')';
425
426 if ( isset ($sql_aro_group_ids) ) {
427 $query .= ' OR rg.id IN ('. $sql_aro_group_ids .')';
428
429 $order_by[] = '(CASE WHEN ar.value IS NULL THEN 0 ELSE 1 END) DESC';
430 $order_by[] = '(rg.rgt-rg.lft) ASC';
431 }
432
433 $query .= ')';
434 }
435
436
437 // if we are querying an axo group
438 if ($axo_section_value == $this->_group_switch) {
439 // if acl_get_groups did not return an array
440 if ( !isset ($sql_axo_group_ids) ) {
441 $this->debug_text ('acl_query(): Invalid AXO Group: '. $axo_value);
442 return FALSE;
443 }
444
445 $query .= '
446 AND xg.id IN ('. $sql_axo_group_ids .')';
447
448 $order_by[] = '(xg.rgt-xg.lft) ASC';
449 } else {
450 $query .= '
451 AND (';
452
453 if ($axo_section_value == '' AND $axo_value == '') {
454 $query .= '(ax.section_value IS NULL AND ax.value IS NULL)';
455 } else {
456 $query .= '(ax.section_value='. $this->db->quote($axo_section_value) .' AND ax.value='. $this->db->quote($axo_value) .')';
457 }
458
459 if (isset($sql_axo_group_ids)) {
460 $query .= ' OR xg.id IN ('. $sql_axo_group_ids .')';
461
462 $order_by[] = '(CASE WHEN ax.value IS NULL THEN 0 ELSE 1 END) DESC';
463 $order_by[] = '(xg.rgt-xg.lft) ASC';
464 } else {
465 $query .= ' AND axg.group_id IS NULL';
466 }
467
468 $query .= ')';
469 }
470
471 /*
472 * The ordering is always very tricky and makes all the difference in the world.
473 * Order (ar.value IS NOT NULL) DESC should put ACLs given to specific AROs
474 * ahead of any ACLs given to groups. This works well for exceptions to groups.
475 * If the $return_all parameter is set to TRUE, then will return the entire
476 * array of applicable ACL information (this option was added by OpenEMR)
477 */
478
479 $order_by[] = 'a.updated_date DESC';
480
481 $query .= '
482 ORDER BY '. implode (',', $order_by) . '
483 ';
484
485 // we are only interested in the first row unless $return_all is set
486 if ($return_all) {
487 $rs = $this->db->Execute($query);
488 }
489 else {
490 $rs = $this->db->SelectLimit($query, 1);
491 }
492
493 if (!is_object($rs)) {
494 $this->debug_db('acl_query');
495 return FALSE;
496 }
497
498 if ($return_all) {
499 while ($arr =& $rs->fetchRow()) {
500 $row[] = $arr;
501 }
502 }
503 else {
504 $row =& $rs->FetchRow();
505 }
506
507
508 /*
509 * Return ACL ID. This is the key to "hooking" extras like pricing assigned to ACLs etc... Very useful.
510 */
511 if (is_array($row)) {
512
513 if ($return_all) {
514 foreach ($row as $single_row) {
515 $allow = FALSE;
516 if ( isset($single_row[1]) AND $single_row[1] == 1 ) {
517 $allow = TRUE;
518 }
519 $retarr[] = array('acl_id' => &$single_row[0], 'return_value' => &$single_row[2], 'allow' => $allow);
520 }
521 }
522 else {
523 $allow = FALSE;
524 if ( isset($row[1]) AND $row[1] == 1 ) {
525 $allow = TRUE;
526 }
527 $retarr = array('acl_id' => &$row[0], 'return_value' => &$row[2], 'allow' => $allow);
528 }
529 } else {
530 if ($return_all) {
531 // Permission denied.
532 $retarr[] = array('acl_id' => NULL, 'return_value' => NULL, 'allow' => FALSE);
533 }
534 else {
535 // Permission denied.
536 $retarr = array('acl_id' => NULL, 'return_value' => NULL, 'allow' => FALSE);
537 }
538 }
539
540 /*
541 * Return the query that we ran if in debug mode.
542 */
543 if ($debug == TRUE) {
544 $retarr['query'] = &$query;
545 }
546
547 //Cache data.
548 $this->put_cache($retarr, $cache_id);
549 }
550
551 if ($return_all)
552 {
553 $this->debug_text("<b>acl_query():</b> ACO Section: $aco_section_value ACO Value: $aco_value ARO Section: $aro_section_value ARO Value $aro_value ACL ID: OMITTED due to return_all");
554 }
555 else
556 {
557 $this->debug_text("<b>acl_query():</b> ACO Section: $aco_section_value ACO Value: $aco_value ARO Section: $aro_section_value ARO Value $aro_value ACL ID: ". $retarr['acl_id'] .' Result: '. $retarr['allow']);
558 }
559
560 return $retarr;
561 }
562
563 /**
564 * Grabs all groups mapped to an ARO. You can also specify a root_group for subtree'ing.
565 * @param string The section value or the ARO or ACO
566 * @param string The value of the ARO or ACO
567 * @param integer The group id of the group to start at (optional)
568 * @param string The type of group, either ARO or AXO (optional)
569 */
570 function acl_get_groups($section_value, $value, $root_group=NULL, $group_type='ARO') {
571
572 switch(strtolower($group_type)) {
573 case 'axo':
574 $group_type = 'axo';
575 $object_table = $this->_db_table_prefix .'axo';
576 $group_table = $this->_db_table_prefix .'axo_groups';
577 $group_map_table = $this->_db_table_prefix .'groups_axo_map';
578 break;
579 default:
580 $group_type = 'aro';
581 $object_table = $this->_db_table_prefix .'aro';
582 $group_table = $this->_db_table_prefix .'aro_groups';
583 $group_map_table = $this->_db_table_prefix .'groups_aro_map';
584 break;
585 }
586
587 //$profiler->startTimer( "acl_get_groups()");
588
589 //Generate unique cache id.
590 $cache_id = 'acl_get_groups_'.$section_value.'-'.$value.'-'.$root_group.'-'.$group_type;
591
592 $retarr = $this->get_cache($cache_id);
593
594 if (!$retarr) {
595
596 // Make sure we get the groups
597 $query = '
598 SELECT DISTINCT g2.id';
599
600 if ($section_value == $this->_group_switch) {
601 $query .= '
602 FROM ' . $group_table . ' g1,' . $group_table . ' g2';
603
604 $where = '
605 WHERE g1.value=' . $this->db->quote( $value );
606 } else {
607 $query .= '
608 FROM '. $object_table .' o,'. $group_map_table .' gm,'. $group_table .' g1,'. $group_table .' g2';
609
610 $where = '
611 WHERE (o.section_value='. $this->db->quote($section_value) .' AND o.value='. $this->db->quote($value) .')
612 AND gm.'. $group_type .'_id=o.id
613 AND g1.id=gm.group_id';
614 }
615
616 /*
617 * If root_group_id is specified, we have to narrow this query down
618 * to just groups deeper in the tree then what is specified.
619 * This essentially creates a virtual "subtree" and ignores all outside groups.
620 * Useful for sites like sourceforge where you may seperate groups by "project".
621 */
622 if ( $root_group != '') {
623 //It is important to note the below line modifies the tables being selected.
624 //This is the reason for the WHERE variable.
625 $query .= ','. $group_table .' g3';
626
627 $where .= '
628 AND g3.value='. $this->db->quote( $root_group ) .'
629 AND ((g2.lft BETWEEN g3.lft AND g1.lft) AND (g2.rgt BETWEEN g1.rgt AND g3.rgt))';
630 } else {
631 $where .= '
632 AND (g2.lft <= g1.lft AND g2.rgt >= g1.rgt)';
633 }
634
635 $query .= $where;
636
637 // $this->debug_text($query);
638 $rs = $this->db->Execute($query);
639
640 if (!is_object($rs)) {
641 $this->debug_db('acl_get_groups');
642 return FALSE;
643 }
644
645 $retarr = array();
646
647 //Unbuffered query?
648 while (!$rs->EOF) {
649 $retarr[] = reset($rs->fields);
650 $rs->MoveNext();
651 }
652
653 //Cache data.
654 $this->put_cache($retarr, $cache_id);
655 }
656
657 return $retarr;
658 }
659
660 /**
661 * Uses PEAR's Cache_Lite package to grab cached arrays, objects, variables etc...
662 * using unserialize() so it can handle more then just text string.
663 * @param string The id of the cached object
664 * @return mixed The cached object, otherwise FALSE if the object identifier was not found
665 */
666 function get_cache($cache_id) {
667
668 if ( $this->_caching == TRUE ) {
669 $this->debug_text("get_cache(): on ID: $cache_id");
670
671 if ( is_string($this->Cache_Lite->get($cache_id) ) ) {
672 return unserialize($this->Cache_Lite->get($cache_id) );
673 }
674 }
675
676 return false;
677 }
678
679 /**
680 * Uses PEAR's Cache_Lite package to write cached arrays, objects, variables etc...
681 * using serialize() so it can handle more then just text string.
682 * @param mixed A variable to cache
683 * @param string The id of the cached variable
684 */
685 function put_cache($data, $cache_id) {
686
687 if ( $this->_caching == TRUE ) {
688 $this->debug_text("put_cache(): Cache MISS on ID: $cache_id");
689
690 return $this->Cache_Lite->save(serialize($data), $cache_id);
691 }
692
693 return false;
694 }
695 }
696 ?>
Mirror of official OpenEMR Sourceforge repository