View | Details | Raw Unified | Return to bug 30920
Collapse All | Expand All

(-)a/C4/Biblio.pm (-10 / +57 lines)
Lines 98-103 use C4::Charset qw( Link Here
98
    SetUTF8Flag
98
    SetUTF8Flag
99
    StripNonXmlChars
99
    StripNonXmlChars
100
);
100
);
101
use C4::Languages;
101
use C4::Linker;
102
use C4::Linker;
102
use C4::OAI::Sets;
103
use C4::OAI::Sets;
103
use C4::Items qw( GetHiddenItemnumbers GetMarcItem );
104
use C4::Items qw( GetHiddenItemnumbers GetMarcItem );
Lines 1464-1488 descriptions rather than normal ones when they exist. Link Here
1464
sub GetAuthorisedValueDesc {
1465
sub GetAuthorisedValueDesc {
1465
    my ( $tag, $subfield, $value, $framework, $tagslib, $category, $opac ) = @_;
1466
    my ( $tag, $subfield, $value, $framework, $tagslib, $category, $opac ) = @_;
1466
1467
1468
    my $cache     = Koha::Caches->get_instance();
1469
    my $cache_key;
1467
    if ( !$category ) {
1470
    if ( !$category ) {
1468
1471
1469
        return $value unless defined $tagslib->{$tag}->{$subfield}->{'authorised_value'};
1472
        return $value unless defined $tagslib->{$tag}->{$subfield}->{'authorised_value'};
1470
1473
1471
        #---- branch
1474
        #---- branch
1472
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "branches" ) {
1475
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "branches" ) {
1473
            my $branch = Koha::Libraries->find($value);
1476
            $cache_key = "LibraryNames";
1474
            return $branch? $branch->branchname: q{};
1477
            my $libraries = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
1478
            if ( !$libraries ) {
1479
                $libraries = {
1480
                    map { $_->branchcode => $_->branchname }
1481
                      Koha::Libraries->search( {},
1482
                        { columns => [ 'branchcode', 'branchname' ] } )
1483
                      ->as_list
1484
                };
1485
                $cache->set_in_cache($cache_key, $libraries);
1486
            }
1487
            return $libraries->{$value};
1475
        }
1488
        }
1476
1489
1477
        #---- itemtypes
1490
        #---- itemtypes
1478
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "itemtypes" ) {
1491
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "itemtypes" ) {
1479
            my $itemtype = Koha::ItemTypes->find( $value );
1492
            my $lang = C4::Languages::getlanguage;
1480
            return $itemtype ? $itemtype->translated_description : q||;
1493
            $lang //= 'en';
1494
            $cache_key = $lang . 'ItemTypeDescriptions';
1495
            my $itypes = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
1496
            if ( !$itypes ) {
1497
                $itypes =
1498
                  { map { $_->itemtype => $_->translated_description }
1499
                      Koha::ItemTypes->search()->as_list };
1500
                $cache->set_in_cache( $cache_key, $itypes );
1501
            }
1502
            return $itypes->{$value};
1481
        }
1503
        }
1482
1504
1483
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "cn_source" ) {
1505
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "cn_source" ) {
1484
            my $source = GetClassSource($value);
1506
            $cache_key = "ClassSources";
1485
            return $source ? $source->{description} : q||;
1507
            my $cn_sources = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
1508
            if ( !$cn_sources ) {
1509
                $cn_sources = {
1510
                    map { $_->cn_source => $_->description }
1511
                      Koha::ClassSources->search( {},
1512
                        { columns => [ 'cn_source', 'description' ] } )
1513
                      ->as_list
1514
                };
1515
                $cache->set_in_cache($cache_key, $cn_sources);
1516
            }
1517
            return $cn_sources->{$value};
1486
        }
1518
        }
1487
1519
1488
        #---- "true" authorized value
1520
        #---- "true" authorized value
Lines 1491-1500 sub GetAuthorisedValueDesc { Link Here
1491
1523
1492
    my $dbh = C4::Context->dbh;
1524
    my $dbh = C4::Context->dbh;
1493
    if ( $category ne "" ) {
1525
    if ( $category ne "" ) {
1494
        my $sth = $dbh->prepare( "SELECT lib, lib_opac FROM authorised_values WHERE category = ? AND authorised_value = ?" );
1526
        $cache_key = "AVDescriptions-" . $category;
1495
        $sth->execute( $category, $value );
1527
        my $av_descriptions = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
1496
        my $data = $sth->fetchrow_hashref;
1528
        if ( !$av_descriptions ) {
1497
        return ( $opac && $data->{'lib_opac'} ) ? $data->{'lib_opac'} : $data->{'lib'};
1529
            $av_descriptions = {
1530
                map {
1531
                    $_->authorised_value =>
1532
                      { lib => $_->lib, lib_opac => $_->lib_opac }
1533
                } Koha::AuthorisedValues->search(
1534
                    { category => $category },
1535
                    {
1536
                        columns => [ 'authorised_value', 'lib_opac', 'lib' ]
1537
                    }
1538
                )->as_list
1539
            };
1540
            $cache->set_in_cache($cache_key, $av_descriptions);
1541
        }
1542
        return ( $opac && $av_descriptions->{$value}->{'lib_opac'} )
1543
          ? $av_descriptions->{$value}->{'lib_opac'}
1544
          : $av_descriptions->{$value}->{'lib'};
1498
    } else {
1545
    } else {
1499
        return $value;    # if nothing is found return the original value
1546
        return $value;    # if nothing is found return the original value
1500
    }
1547
    }
(-)a/Koha/AuthorisedValue.pm (-1 / +32 lines)
Lines 19-25 package Koha::AuthorisedValue; Link Here
19
19
20
use Modern::Perl;
20
use Modern::Perl;
21
21
22
22
use Koha::Caches;
23
use Koha::Database;
23
use Koha::Database;
24
24
25
use base qw(Koha::Object Koha::Object::Limit::Library);
25
use base qw(Koha::Object Koha::Object::Limit::Library);
Lines 34-39 Koha::AuthorisedValue - Koha Authorised value Object class Link Here
34
34
35
=cut
35
=cut
36
36
37
=head3 store
38
39
AuthorisedValue specific store to ensure relevant caches are flushed on change
40
41
=cut
42
43
sub store {
44
    my ($self) = @_;
45
46
    my $flush = 0;
47
48
    if ( !$self->in_storage ) {
49
        $flush = 1;
50
    }
51
    else {
52
        my $self_from_storage = $self->get_from_storage;
53
        $flush = 1 if ( $self_from_storage->lib ne $self->lib );
54
        $flush = 1 if ( $self_from_storage->lib_opac ne $self->lib_opac );
55
    }
56
57
    $self = $self->SUPER::store;
58
59
    if ($flush) {
60
        my $cache = Koha::Caches->get_instance();
61
        my $key = "AVDescriptions-".$self->category;
62
        $cache->clear_from_cache($key);
63
    }
64
65
    return $self;
66
}
67
37
=head3 opac_description
68
=head3 opac_description
38
69
39
my $description = $av->opac_description();
70
my $description = $av->opac_description();
(-)a/Koha/ClassSource.pm (-1 / +28 lines)
Lines 17-23 package Koha::ClassSource; Link Here
17
17
18
use Modern::Perl;
18
use Modern::Perl;
19
19
20
20
use Koha::Caches;
21
use Koha::Database;
21
use Koha::Database;
22
22
23
use base qw(Koha::Object);
23
use base qw(Koha::Object);
Lines 30-37 Koha::ClassSource - Koha Classfication Source Object class Link Here
30
30
31
=head2 Class Methods
31
=head2 Class Methods
32
32
33
=head3 store
34
35
ClassSource specific store to ensure relevant caches are flushed on change
36
33
=cut
37
=cut
34
38
39
sub store {
40
    my ($self) = @_;
41
42
    my $flush = 0;
43
44
    if ( !$self->in_storage ) {
45
        $flush = 1;
46
    }
47
    else {
48
        my $self_from_storage = $self->get_from_storage;
49
        $flush = 1 if ( $self_from_storage->description ne $self->description );
50
    }
51
52
    $self = $self->SUPER::store;
53
54
    if ($flush) {
55
        my $cache = Koha::Caches->get_instance();
56
        $cache->clear_from_cache('ClassSources');
57
    }
58
59
    return $self;
60
}
61
35
=head3 _type
62
=head3 _type
36
63
37
Returns name of corresponding DBIC resultset
64
Returns name of corresponding DBIC resultset
(-)a/Koha/ItemType.pm (+31 lines)
Lines 20-25 use Modern::Perl; Link Here
20
20
21
use C4::Koha qw( getitemtypeimagelocation );
21
use C4::Koha qw( getitemtypeimagelocation );
22
use C4::Languages;
22
use C4::Languages;
23
use Koha::Caches;
23
use Koha::Database;
24
use Koha::Database;
24
use Koha::CirculationRules;
25
use Koha::CirculationRules;
25
use Koha::Localizations;
26
use Koha::Localizations;
Lines 36-41 Koha::ItemType - Koha Item type Object class Link Here
36
37
37
=cut
38
=cut
38
39
40
=head3 store
41
42
ItemType specific store to ensure relevant caches are flushed on change
43
44
=cut
45
46
sub store {
47
    my ($self) = @_;
48
49
    my $flush = 0;
50
51
    if ( !$self->in_storage ) {
52
        $flush = 1;
53
    }
54
    else {
55
        my $self_from_storage = $self->get_from_storage;
56
        $flush = 1 if ( $self_from_storage->description ne $self->description );
57
    }
58
59
    $self = $self->SUPER::store;
60
61
    if ($flush) {
62
        my $cache = Koha::Caches->get_instance();
63
        my $key = "enItemTypeDescriptions";
64
        $cache->clear_from_cache($key);
65
    }
66
67
    return $self;
68
}
69
39
=head3 image_location
70
=head3 image_location
40
71
41
=cut
72
=cut
(-)a/Koha/Library.pm (+30 lines)
Lines 22-27 use Modern::Perl; Link Here
22
22
23
use C4::Context;
23
use C4::Context;
24
24
25
use Koha::Caches;
25
use Koha::Database;
26
use Koha::Database;
26
use Koha::StockRotationStages;
27
use Koha::StockRotationStages;
27
use Koha::SMTP::Servers;
28
use Koha::SMTP::Servers;
Lines 36-41 Koha::Library - Koha Library Object class Link Here
36
37
37
=head2 Class methods
38
=head2 Class methods
38
39
40
=head3 store
41
42
Library specific store to ensure relevant caches are flushed on change
43
44
=cut
45
46
sub store {
47
    my ($self) = @_;
48
49
    my $flush = 0;
50
51
    if ( !$self->in_storage ) {
52
        $flush = 1;
53
    }
54
    else {
55
        my $self_from_storage = $self->get_from_storage;
56
        $flush = 1 if ( $self_from_storage->branchname ne $self->branchname );
57
    }
58
59
    $self = $self->SUPER::store;
60
61
    if ($flush) {
62
        my $cache = Koha::Caches->get_instance();
63
        $cache->clear_from_cache('LibraryNames');
64
    }
65
66
    return $self;
67
}
68
39
=head3 stockrotationstages
69
=head3 stockrotationstages
40
70
41
  my $stages = Koha::Library->stockrotationstages;
71
  my $stages = Koha::Library->stockrotationstages;
(-)a/Koha/Localization.pm (-1 / +29 lines)
Lines 21-26 use Koha::Database; Link Here
21
21
22
use base qw(Koha::Object);
22
use base qw(Koha::Object);
23
23
24
=head1 NAME
25
26
Koha::Localization - Koha Localization type Object class
27
28
=head1 API
29
30
=head2 Class methods
31
32
=cut
33
34
=head3 store
35
36
Localization specific store to ensure relevant caches are flushed on change
37
38
=cut
39
40
sub store {
41
    my ($self) = @_;
42
    $self = $self->SUPER::store;
43
44
    if ($self->entity eq 'itemtypes') {
45
        my $cache = Koha::Caches->get_instance();
46
        my $key = $self->lang."ItemTypeDescriptions";
47
        $cache->clear_from_cache($key);
48
    }
49
50
    return $self;
51
}
52
24
sub _type {
53
sub _type {
25
    return 'Localization';
54
    return 'Localization';
26
}
55
}
27
- 

Return to bug 30920