|
package SL::DB::Helper::Manager;
|
|
|
|
use strict;
|
|
|
|
use Carp;
|
|
|
|
use Rose::DB::Object::Manager;
|
|
use base qw(Rose::DB::Object::Manager);
|
|
|
|
sub make_manager_methods {
|
|
my $class = shift;
|
|
my @params = scalar(@_) ? @_ : qw(all);
|
|
return $class->SUPER::make_manager_methods(@params);
|
|
}
|
|
|
|
sub find_by {
|
|
my $class = shift;
|
|
|
|
return if !@_;
|
|
return $class->get_all(query => [ @_ ], limit => 1)->[0];
|
|
}
|
|
|
|
sub find_by_or_create {
|
|
my $class = shift;
|
|
|
|
my $found;
|
|
eval {
|
|
$found = $class->find_by(@_);
|
|
1;
|
|
} or die $@;
|
|
return defined $found ? $found : $class->object_class->new;
|
|
}
|
|
|
|
sub get_first {
|
|
shift->get_all(
|
|
@_,
|
|
limit => 1,
|
|
)->[0];
|
|
}
|
|
|
|
sub cache_all {
|
|
my $manager_class = shift;
|
|
my $class = $manager_class;
|
|
$class =~ s{Manager::}{};
|
|
|
|
croak "Caching can only be used with classes with exactly one primary key column" if 1 != scalar(@{ $class->meta->primary_key_columns });
|
|
|
|
my $all_have_been_cached = $::request->cache("::SL::DB::Manager::cache_all");
|
|
return if $all_have_been_cached->{$class};
|
|
|
|
$all_have_been_cached->{$class} = 1;
|
|
|
|
my $item_cache = $::request->cache("::SL::DB::Object::object_cache::${class}");
|
|
my $primary_key = $class->meta->primary_key_columns->[0]->name;
|
|
my $objects = $class->_get_manager_class->get_all;
|
|
|
|
$item_cache->{$_->$primary_key} = $_ for @{ $objects};
|
|
}
|
|
|
|
1;
|
|
__END__
|
|
|
|
=pod
|
|
|
|
=encoding utf8
|
|
|
|
=head1 NAME
|
|
|
|
SL::DB::Helper::Manager - Base class & helper functions for all Rose manager classes
|
|
|
|
=head1 FUNCTIONS
|
|
|
|
=over 4
|
|
|
|
=item C<cache_all>
|
|
|
|
Pre-caches all items from a table. Use this is you expect to need all
|
|
items from a table. You can retrieve them later with the
|
|
C<load_cached> function from the corresponding Rose DB object class.
|
|
|
|
For example, if you expect to need all unit objects, you can use
|
|
C<SL::DB::Manager::Unit-E<gt>cache_all> before you start the actual
|
|
work. Later you can use C<SL::DB::Unit-E<gt>load_cached> to retrieve
|
|
individual objects and be sure that they're already cached.
|
|
|
|
=item C<find_by @where>
|
|
|
|
Retrieves one item from the corresponding table matching the
|
|
conditions given in C<@where>.
|
|
|
|
This is shorthand for the following call:
|
|
|
|
SL::DB::Manager::SomeClass->get_all(where => [ … ], limit => 1)
|
|
|
|
=item C<find_by_or_create @where>
|
|
|
|
This calls L</find_by> with C<@where> and returns its result if one is
|
|
found.
|
|
|
|
If none is found, a new instance of the corresponding DB object class
|
|
is created and returned. Such a new object is not inserted into the
|
|
database automatically.
|
|
|
|
=item C<get_first @args>
|
|
|
|
Retrieves the first item from the database by calling C<get_all> with
|
|
a limit of 1. The C<@args> are passed through to C<get_all> allowing
|
|
for arbitrary filters and sort options to be applied.
|
|
|
|
=item C<make_manager_methods [@method_list]>
|
|
|
|
Calls Rose's C<make_manager_methods> with the C<@method_list> or
|
|
C<all> if no methods are given.
|
|
|
|
=back
|
|
|
|
=head1 BUGS
|
|
|
|
Nothing here yet.
|
|
|
|
=head1 AUTHOR
|
|
|
|
Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
|
|
|
|
=cut
|