Lines 32-38
BEGIN {
Link Here
|
32 |
eval {C4::Context->dbh();}; |
32 |
eval {C4::Context->dbh();}; |
33 |
if ($@){ |
33 |
if ($@){ |
34 |
$debug_level = 1; |
34 |
$debug_level = 1; |
35 |
} |
35 |
} |
36 |
else { |
36 |
else { |
37 |
$debug_level = C4::Context->preference("DebugLevel"); |
37 |
$debug_level = C4::Context->preference("DebugLevel"); |
38 |
} |
38 |
} |
Lines 50-56
BEGIN {
Link Here
|
50 |
# a little example table with various version info"; |
50 |
# a little example table with various version info"; |
51 |
print " |
51 |
print " |
52 |
<h1>Koha error</h1> |
52 |
<h1>Koha error</h1> |
53 |
<p>The following fatal error has occurred:</p> |
53 |
<p>The following fatal error has occurred:</p> |
54 |
<pre><code>$msg</code></pre> |
54 |
<pre><code>$msg</code></pre> |
55 |
<table> |
55 |
<table> |
56 |
<tr><th>Apache</th><td> $versions{apacheVersion}</td></tr> |
56 |
<tr><th>Apache</th><td> $versions{apacheVersion}</td></tr> |
Lines 64-74
BEGIN {
Link Here
|
64 |
} elsif ($debug_level eq "1"){ |
64 |
} elsif ($debug_level eq "1"){ |
65 |
print " |
65 |
print " |
66 |
<h1>Koha error</h1> |
66 |
<h1>Koha error</h1> |
67 |
<p>The following fatal error has occurred:</p> |
67 |
<p>The following fatal error has occurred:</p> |
68 |
<pre><code>$msg</code></pre>"; |
68 |
<pre><code>$msg</code></pre>"; |
69 |
} else { |
69 |
} else { |
70 |
print "<p>production mode - trapped fatal error</p>"; |
70 |
print "<p>production mode - trapped fatal error</p>"; |
71 |
} |
71 |
} |
72 |
print "</body></html>"; |
72 |
print "</body></html>"; |
73 |
} |
73 |
} |
74 |
#CGI::Carp::set_message(\&handle_errors); |
74 |
#CGI::Carp::set_message(\&handle_errors); |
Lines 95-100
use Koha::Caches;
Link Here
|
95 |
use POSIX (); |
95 |
use POSIX (); |
96 |
use DateTime::TimeZone; |
96 |
use DateTime::TimeZone; |
97 |
use Module::Load::Conditional qw(can_load); |
97 |
use Module::Load::Conditional qw(can_load); |
|
|
98 |
use Data::Dumper; |
98 |
use Carp; |
99 |
use Carp; |
99 |
|
100 |
|
100 |
use C4::Boolean; |
101 |
use C4::Boolean; |
Lines 163-176
environment variable to the pathname of a configuration file to use.
Link Here
|
163 |
# file (/etc/koha/koha-conf.xml). |
164 |
# file (/etc/koha/koha-conf.xml). |
164 |
# dbh |
165 |
# dbh |
165 |
# A handle to the appropriate database for this context. |
166 |
# A handle to the appropriate database for this context. |
166 |
# dbh_stack |
|
|
167 |
# Used by &set_dbh and &restore_dbh to hold other database |
168 |
# handles for this context. |
169 |
# Zconn |
170 |
# A connection object for the Zebra server |
167 |
# A connection object for the Zebra server |
171 |
|
168 |
|
172 |
$context = undef; # Initially, no context is set |
169 |
@context_stack = (); # Initially, no saved contexts |
173 |
@context_stack = (); # Initially, no saved contexts |
170 |
|
|
|
171 |
=head2 current |
172 |
|
173 |
Returns the current context |
174 |
|
175 |
=cut |
176 |
|
177 |
sub current { |
178 |
return $context; |
179 |
} |
180 |
|
181 |
sub db_driver { |
182 |
my $self = shift; |
183 |
|
184 |
$self = $context unless ref ($self); |
185 |
return unless $self; |
186 |
|
187 |
return $self->{db_driver}; |
188 |
} |
174 |
|
189 |
|
175 |
=head2 db_scheme2dbi |
190 |
=head2 db_scheme2dbi |
176 |
|
191 |
|
Lines 192-223
sub import {
Link Here
|
192 |
# Create the default context ($C4::Context::Context) |
207 |
# Create the default context ($C4::Context::Context) |
193 |
# the first time the module is called |
208 |
# the first time the module is called |
194 |
# (a config file can be optionaly passed) |
209 |
# (a config file can be optionaly passed) |
|
|
210 |
# If ":no_config" is passed, no config load will be attempted |
211 |
# It saves the context values in the declared memcached server(s) |
212 |
# if currently available and uses those values until them expire and |
213 |
# re-reads them. |
214 |
|
215 |
my ($pkg,$config_file) = @_; |
195 |
|
216 |
|
196 |
# default context already exists? |
217 |
# default context already exists? |
197 |
return if $context; |
218 |
return if $context; |
198 |
|
219 |
|
199 |
# no ? so load it! |
220 |
# multihost, we don't want/have one default config |
200 |
my ($pkg,$config_file) = @_ ; |
221 |
return if $config_file && $config_file eq ":no_config"; |
201 |
my $new_ctx = __PACKAGE__->new($config_file); |
222 |
|
202 |
return unless $new_ctx; |
223 |
my $conf_cache = Koha::Caches->get_instance('config'); |
|
|
224 |
if ( $conf_cache->cache ) { |
225 |
if ( $context = $conf_cache->get_from_cache('koha_conf') ) { |
226 |
return; |
227 |
} |
228 |
} |
229 |
|
230 |
undef $config_file if $config_file && !-s $config_file; |
231 |
$config_file ||= Koha::Config->guess_koha_conf(); |
232 |
$context = __PACKAGE__->new($config_file); |
233 |
return unless $context; |
203 |
|
234 |
|
204 |
# if successfully loaded, use it by default |
235 |
if ( $conf_cache->memcached_cache ) { |
205 |
$new_ctx->set_context; |
236 |
# FIXME it may be better to use the memcached servers from the config file |
206 |
1; |
237 |
# to cache it |
|
|
238 |
$conf_cache->set_in_cache('koha_conf', $context) |
239 |
} |
207 |
} |
240 |
} |
208 |
|
241 |
|
209 |
=head2 new |
242 |
=head2 new |
210 |
|
243 |
|
211 |
$context = new C4::Context; |
|
|
212 |
$context = new C4::Context("/path/to/koha-conf.xml"); |
244 |
$context = new C4::Context("/path/to/koha-conf.xml"); |
213 |
|
245 |
|
214 |
Allocates a new context. Initializes the context from the specified |
246 |
Allocates a new context. Initializes the context from the specified |
215 |
file, which defaults to either the file given by the C<$KOHA_CONF> |
247 |
file. |
216 |
environment variable, or F</etc/koha/koha-conf.xml>. |
|
|
217 |
|
218 |
It saves the koha-conf.xml values in the declared memcached server(s) |
219 |
if currently available and uses those values until them expire and |
220 |
re-reads them. |
221 |
|
248 |
|
222 |
C<&new> does not set this context as the new default context; for |
249 |
C<&new> does not set this context as the new default context; for |
223 |
that, use C<&set_context>. |
250 |
that, use C<&set_context>. |
Lines 229-266
that, use C<&set_context>.
Link Here
|
229 |
# 2004-08-10 A. Tarallo: Added check if the conf file is not empty |
256 |
# 2004-08-10 A. Tarallo: Added check if the conf file is not empty |
230 |
sub new { |
257 |
sub new { |
231 |
my $class = shift; |
258 |
my $class = shift; |
232 |
my $conf_fname = shift; # Config file to load |
259 |
my $conf_fname = shift or croak "No conf"; |
233 |
my $self = {}; |
260 |
my $namespace = shift; |
234 |
|
|
|
235 |
# check that the specified config file exists and is not empty |
236 |
undef $conf_fname unless |
237 |
(defined $conf_fname && -s $conf_fname); |
238 |
# Figure out a good config file to load if none was specified. |
239 |
unless ( defined $conf_fname ) { |
240 |
$conf_fname = Koha::Config->guess_koha_conf; |
241 |
unless ( $conf_fname ) { |
242 |
warn "unable to locate Koha configuration file koha-conf.xml"; |
243 |
return; |
244 |
} |
245 |
} |
246 |
|
261 |
|
247 |
my $conf_cache = Koha::Caches->get_instance('config'); |
262 |
my $self = Koha::Config->read_from_file($conf_fname); |
248 |
my $config_from_cache; |
263 |
die "Invalid config ".(ref($conf_fname) ? $$conf_fname : $conf_fname).": ".Dumper($self) |
249 |
if ( $conf_cache->cache ) { |
264 |
unless ref($self) && $self->{"config"}; |
250 |
$self = $conf_cache->get_from_cache('koha_conf'); |
265 |
|
251 |
} |
266 |
$self->{config_file} = $conf_fname; |
252 |
unless ( $self and %$self ) { |
267 |
$self->{namespace} = $namespace; |
253 |
$self = Koha::Config->read_from_file($conf_fname); |
268 |
$self->{use_syspref_cache} = 1; |
254 |
if ( $conf_cache->memcached_cache ) { |
269 |
$self->{syspref_cache} = Koha::Cache->new({namespace => $namespace}); |
255 |
# FIXME it may be better to use the memcached servers from the config file |
|
|
256 |
# to cache it |
257 |
$conf_cache->set_in_cache('koha_conf', $self) |
258 |
} |
259 |
} |
260 |
unless ( exists $self->{config} or defined $self->{config} ) { |
261 |
warn "The config file ($conf_fname) has not been parsed correctly"; |
262 |
return; |
263 |
} |
264 |
|
270 |
|
265 |
$self->{"Zconn"} = undef; # Zebra Connections |
271 |
$self->{"Zconn"} = undef; # Zebra Connections |
266 |
$self->{"userenv"} = undef; # User env |
272 |
$self->{"userenv"} = undef; # User env |
Lines 275-281
sub new {
Link Here
|
275 |
|
281 |
|
276 |
=head2 set_context |
282 |
=head2 set_context |
277 |
|
283 |
|
278 |
$context = new C4::Context; |
|
|
279 |
$context->set_context(); |
284 |
$context->set_context(); |
280 |
or |
285 |
or |
281 |
set_context C4::Context $context; |
286 |
set_context C4::Context $context; |
Lines 308-324
sub set_context
Link Here
|
308 |
if (ref($self) eq "") |
313 |
if (ref($self) eq "") |
309 |
{ |
314 |
{ |
310 |
# Class method. The new context is the next argument. |
315 |
# Class method. The new context is the next argument. |
311 |
$new_context = shift; |
316 |
$new_context = shift or croak "No new context"; |
312 |
} else { |
317 |
} else { |
313 |
# Instance method. The new context is $self. |
318 |
# Instance method. The new context is $self. |
314 |
$new_context = $self; |
319 |
$new_context = $self; |
315 |
} |
320 |
} |
316 |
|
321 |
|
317 |
# Save the old context, if any, on the stack |
322 |
# undef $new_context->{schema} if $new_context->{schema} && !$new_context->{schema}->ping |
318 |
push @context_stack, $context if defined($context); |
323 |
my $schema = $new_context->{schema} ||= Koha::Database->new_schema($new_context); |
|
|
324 |
|
325 |
# Save the old context on the stack |
326 |
push @context_stack, $context; |
319 |
|
327 |
|
320 |
# Set the new context |
328 |
# Set the new context |
321 |
$context = $new_context; |
329 |
$context = $new_context; |
|
|
330 |
Koha::Database->set_schema($schema); |
322 |
} |
331 |
} |
323 |
|
332 |
|
324 |
=head2 restore_context |
333 |
=head2 restore_context |
Lines 334-352
sub restore_context
Link Here
|
334 |
{ |
343 |
{ |
335 |
my $self = shift; |
344 |
my $self = shift; |
336 |
|
345 |
|
337 |
if ($#context_stack < 0) |
|
|
338 |
{ |
339 |
# Stack underflow. |
340 |
die "Context stack underflow"; |
341 |
} |
342 |
|
343 |
# Pop the old context and set it. |
346 |
# Pop the old context and set it. |
344 |
$context = pop @context_stack; |
347 |
$context = pop @context_stack; |
|
|
348 |
Koha::Database->restore_schema(); |
345 |
|
349 |
|
346 |
# FIXME - Should this return something, like maybe the context |
350 |
# FIXME - Should this return something, like maybe the context |
347 |
# that was current when this was called? |
351 |
# that was current when this was called? |
348 |
} |
352 |
} |
349 |
|
353 |
|
|
|
354 |
=head2 run_within_context |
355 |
|
356 |
$context->run_within_context(sub {...}); |
357 |
|
358 |
Runs code within context |
359 |
|
360 |
=cut |
361 |
|
362 |
#' |
363 |
sub run_within_context |
364 |
{ |
365 |
my $self = shift; |
366 |
my $code = shift or croak "No code"; |
367 |
|
368 |
$self->set_context; |
369 |
|
370 |
local $@; |
371 |
my $ret = eval { $code->(@_) }; |
372 |
my $died = $@; |
373 |
$self->restore_context; |
374 |
die $died if $died; |
375 |
return $ret; |
376 |
} |
377 |
|
350 |
=head2 config |
378 |
=head2 config |
351 |
|
379 |
|
352 |
$value = C4::Context->config("config_variable"); |
380 |
$value = C4::Context->config("config_variable"); |
Lines 363-388
C<C4::Config-E<gt>new> will not return it.
Link Here
|
363 |
=cut |
391 |
=cut |
364 |
|
392 |
|
365 |
sub _common_config { |
393 |
sub _common_config { |
366 |
my $var = shift; |
394 |
my $self = shift; |
367 |
my $term = shift; |
395 |
my $var = shift; |
368 |
return if !defined($context->{$term}); |
396 |
my $term = shift; |
|
|
397 |
|
398 |
$self = $context unless ref $self; |
399 |
return if !defined($self->{$term}); |
369 |
# Presumably $self->{$term} might be |
400 |
# Presumably $self->{$term} might be |
370 |
# undefined if the config file given to &new |
401 |
# undefined if the config file given to &new |
371 |
# didn't exist, and the caller didn't bother |
402 |
# didn't exist, and the caller didn't bother |
372 |
# to check the return value. |
403 |
# to check the return value. |
373 |
|
404 |
|
374 |
# Return the value of the requested config variable |
405 |
# Return the value of the requested config variable |
375 |
return $context->{$term}->{$var}; |
406 |
return $self->{$term}->{$var}; |
376 |
} |
407 |
} |
377 |
|
408 |
|
378 |
sub config { |
409 |
sub config { |
379 |
return _common_config($_[1],'config'); |
410 |
my $self = shift; |
|
|
411 |
return $self->_common_config($_[0],'config'); |
380 |
} |
412 |
} |
381 |
sub zebraconfig { |
413 |
sub zebraconfig { |
382 |
return _common_config($_[1],'server'); |
414 |
my $self = shift; |
|
|
415 |
return $self->_common_config($_[0],'server'); |
383 |
} |
416 |
} |
384 |
sub ModZebrations { |
417 |
sub ModZebrations { |
385 |
return _common_config($_[1],'serverinfo'); |
418 |
my $self = shift; |
|
|
419 |
return $self->_common_config($_[0],'serverinfo'); |
386 |
} |
420 |
} |
387 |
|
421 |
|
388 |
=head2 preference |
422 |
=head2 preference |
Lines 401-410
with this method.
Link Here
|
401 |
|
435 |
|
402 |
=cut |
436 |
=cut |
403 |
|
437 |
|
404 |
my $syspref_cache = Koha::Caches->get_instance('syspref'); |
|
|
405 |
my $use_syspref_cache = 1; |
406 |
sub preference { |
438 |
sub preference { |
407 |
my $self = shift; |
439 |
my $self = shift; |
|
|
440 |
$self = $context unless ref $self; |
408 |
my $var = shift; # The system preference to return |
441 |
my $var = shift; # The system preference to return |
409 |
|
442 |
|
410 |
$var = lc $var; |
443 |
$var = lc $var; |
Lines 412-419
sub preference {
Link Here
|
412 |
return $ENV{"OVERRIDE_SYSPREF_$var"} |
445 |
return $ENV{"OVERRIDE_SYSPREF_$var"} |
413 |
if defined $ENV{"OVERRIDE_SYSPREF_$var"}; |
446 |
if defined $ENV{"OVERRIDE_SYSPREF_$var"}; |
414 |
|
447 |
|
415 |
my $cached_var = $use_syspref_cache |
448 |
my $cached_var = $self->{use_syspref_cache} |
416 |
? $syspref_cache->get_from_cache("syspref_$var") |
449 |
? $self->{syspref_cache}->get_from_cache("syspref_$var") |
417 |
: undef; |
450 |
: undef; |
418 |
return $cached_var if defined $cached_var; |
451 |
return $cached_var if defined $cached_var; |
419 |
|
452 |
|
Lines 421-428
sub preference {
Link Here
|
421 |
eval { $syspref = Koha::Config::SysPrefs->find( lc $var ) }; |
454 |
eval { $syspref = Koha::Config::SysPrefs->find( lc $var ) }; |
422 |
my $value = $syspref ? $syspref->value() : undef; |
455 |
my $value = $syspref ? $syspref->value() : undef; |
423 |
|
456 |
|
424 |
if ( $use_syspref_cache ) { |
457 |
if ( $self->{use_syspref_cache} ) { |
425 |
$syspref_cache->set_in_cache("syspref_$var", $value); |
458 |
$self->{syspref_cache}->set_in_cache("syspref_$var", $value); |
426 |
} |
459 |
} |
427 |
return $value; |
460 |
return $value; |
428 |
} |
461 |
} |
Lines 445-451
default behavior.
Link Here
|
445 |
|
478 |
|
446 |
sub enable_syspref_cache { |
479 |
sub enable_syspref_cache { |
447 |
my ($self) = @_; |
480 |
my ($self) = @_; |
448 |
$use_syspref_cache = 1; |
481 |
$self = $context unless ref $self; |
|
|
482 |
$self->{use_syspref_cache} = 1; |
449 |
# We need to clear the cache to have it up-to-date |
483 |
# We need to clear the cache to have it up-to-date |
450 |
$self->clear_syspref_cache(); |
484 |
$self->clear_syspref_cache(); |
451 |
} |
485 |
} |
Lines 461-467
used with Plack and other persistent environments.
Link Here
|
461 |
|
495 |
|
462 |
sub disable_syspref_cache { |
496 |
sub disable_syspref_cache { |
463 |
my ($self) = @_; |
497 |
my ($self) = @_; |
464 |
$use_syspref_cache = 0; |
498 |
$self = $context unless ref $self; |
|
|
499 |
$self->{use_syspref_cache} = 0; |
465 |
$self->clear_syspref_cache(); |
500 |
$self->clear_syspref_cache(); |
466 |
} |
501 |
} |
467 |
|
502 |
|
Lines 476-483
will not be seen by this process.
Link Here
|
476 |
=cut |
511 |
=cut |
477 |
|
512 |
|
478 |
sub clear_syspref_cache { |
513 |
sub clear_syspref_cache { |
479 |
return unless $use_syspref_cache; |
514 |
my ($self) = @_; |
480 |
$syspref_cache->flush_all; |
515 |
$self = $context unless ref $self; |
|
|
516 |
return unless $self->{use_syspref_cache}; |
517 |
$self->{syspref_cache}->flush_all; |
481 |
} |
518 |
} |
482 |
|
519 |
|
483 |
=head2 set_preference |
520 |
=head2 set_preference |
Lines 493-498
preference.
Link Here
|
493 |
|
530 |
|
494 |
sub set_preference { |
531 |
sub set_preference { |
495 |
my ( $self, $variable, $value, $explanation, $type, $options ) = @_; |
532 |
my ( $self, $variable, $value, $explanation, $type, $options ) = @_; |
|
|
533 |
$self = $context unless ref $self; |
496 |
|
534 |
|
497 |
$variable = lc $variable; |
535 |
$variable = lc $variable; |
498 |
|
536 |
|
Lines 528-535
sub set_preference {
Link Here
|
528 |
)->store(); |
566 |
)->store(); |
529 |
} |
567 |
} |
530 |
|
568 |
|
531 |
if ( $use_syspref_cache ) { |
569 |
if ( $self->{use_syspref_cache} ) { |
532 |
$syspref_cache->set_in_cache( "syspref_$variable", $value ); |
570 |
$self->{syspref_cache}->set_in_cache( "syspref_$variable", $value ); |
533 |
} |
571 |
} |
534 |
|
572 |
|
535 |
return $syspref; |
573 |
return $syspref; |
Lines 547-556
was no syspref of the name.
Link Here
|
547 |
|
585 |
|
548 |
sub delete_preference { |
586 |
sub delete_preference { |
549 |
my ( $self, $var ) = @_; |
587 |
my ( $self, $var ) = @_; |
|
|
588 |
$self = $context unless ref $self; |
550 |
|
589 |
|
551 |
if ( Koha::Config::SysPrefs->find( $var )->delete ) { |
590 |
if ( Koha::Config::SysPrefs->find( $var )->delete ) { |
552 |
if ( $use_syspref_cache ) { |
591 |
if ( $self->{use_syspref_cache} ) { |
553 |
$syspref_cache->clear_from_cache("syspref_$var"); |
592 |
$self->{syspref_cache}->clear_from_cache("syspref_$var"); |
554 |
} |
593 |
} |
555 |
|
594 |
|
556 |
return 1; |
595 |
return 1; |
Lines 564-570
sub delete_preference {
Link Here
|
564 |
|
603 |
|
565 |
Returns a connection to the Zebra database |
604 |
Returns a connection to the Zebra database |
566 |
|
605 |
|
567 |
C<$self> |
606 |
C<$self> |
568 |
|
607 |
|
569 |
C<$server> one of the servers defined in the koha-conf.xml file |
608 |
C<$server> one of the servers defined in the koha-conf.xml file |
570 |
|
609 |
|
Lines 675-682
creates one, and connects to the database.
Link Here
|
675 |
|
714 |
|
676 |
This database handle is cached for future use: if you call |
715 |
This database handle is cached for future use: if you call |
677 |
C<C4::Context-E<gt>dbh> twice, you will get the same handle both |
716 |
C<C4::Context-E<gt>dbh> twice, you will get the same handle both |
678 |
times. If you need a second database handle, use C<&new_dbh> and |
717 |
times. If you need a second database handle, use C<&new_dbh>. |
679 |
possibly C<&set_dbh>. |
|
|
680 |
|
718 |
|
681 |
=cut |
719 |
=cut |
682 |
|
720 |
|
Lines 715-778
sub new_dbh
Link Here
|
715 |
return &dbh({ new => 1 }); |
753 |
return &dbh({ new => 1 }); |
716 |
} |
754 |
} |
717 |
|
755 |
|
718 |
=head2 set_dbh |
|
|
719 |
|
720 |
$my_dbh = C4::Connect->new_dbh; |
721 |
C4::Connect->set_dbh($my_dbh); |
722 |
... |
723 |
C4::Connect->restore_dbh; |
724 |
|
725 |
C<&set_dbh> and C<&restore_dbh> work in a manner analogous to |
726 |
C<&set_context> and C<&restore_context>. |
727 |
|
728 |
C<&set_dbh> saves the current database handle on a stack, then sets |
729 |
the current database handle to C<$my_dbh>. |
730 |
|
731 |
C<$my_dbh> is assumed to be a good database handle. |
732 |
|
733 |
=cut |
734 |
|
735 |
#' |
736 |
sub set_dbh |
737 |
{ |
738 |
my $self = shift; |
739 |
my $new_dbh = shift; |
740 |
|
741 |
# Save the current database handle on the handle stack. |
742 |
# We assume that $new_dbh is all good: if the caller wants to |
743 |
# screw himself by passing an invalid handle, that's fine by |
744 |
# us. |
745 |
push @{$context->{"dbh_stack"}}, $context->{"dbh"}; |
746 |
$context->{"dbh"} = $new_dbh; |
747 |
} |
748 |
|
749 |
=head2 restore_dbh |
750 |
|
751 |
C4::Context->restore_dbh; |
752 |
|
753 |
Restores the database handle saved by an earlier call to |
754 |
C<C4::Context-E<gt>set_dbh>. |
755 |
|
756 |
=cut |
757 |
|
758 |
#' |
759 |
sub restore_dbh |
760 |
{ |
761 |
my $self = shift; |
762 |
|
763 |
if ($#{$context->{"dbh_stack"}} < 0) |
764 |
{ |
765 |
# Stack underflow |
766 |
die "DBH stack underflow"; |
767 |
} |
768 |
|
769 |
# Pop the old database handle and set it. |
770 |
$context->{"dbh"} = pop @{$context->{"dbh_stack"}}; |
771 |
|
772 |
# FIXME - If it is determined that restore_context should |
773 |
# return something, then this function should, too. |
774 |
} |
775 |
|
776 |
=head2 queryparser |
756 |
=head2 queryparser |
777 |
|
757 |
|
778 |
$queryparser = C4::Context->queryparser |
758 |
$queryparser = C4::Context->queryparser |