Attachment #126357 for bug #28445

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

Lines 26-33 use Koha::DateUtils qw( dt_from_string ); Link Here

(-)a/Koha/BackgroundJob.pm (-1 / +5 lines)
26	use Koha::Exceptions;	26	use Koha::Exceptions;
27	use Koha::BackgroundJob::BatchUpdateBiblio;	27	use Koha::BackgroundJob::BatchUpdateBiblio;
28	use Koha::BackgroundJob::BatchUpdateAuthority;	28	use Koha::BackgroundJob::BatchUpdateAuthority;
		29	use Koha::BackgroundJob::BatchUpdateItem;
29	use Koha::BackgroundJob::BatchDeleteBiblio;	30	use Koha::BackgroundJob::BatchDeleteBiblio;
30	use Koha::BackgroundJob::BatchDeleteAuthority;	31	use Koha::BackgroundJob::BatchDeleteAuthority;
		32	use Koha::BackgroundJob::BatchDeleteItem;
31	use Koha::BackgroundJob::BatchCancelHold;	33	use Koha::BackgroundJob::BatchCancelHold;
32		34
33	use base qw( Koha::Object );	35	use base qw( Koha::Object );
Lines 198-204 sub report { Link Here
198	my ( $self ) = @_;	200	my ( $self ) = @_;
199		201
200	my $data_dump = decode_json $self->data;	202	my $data_dump = decode_json $self->data;
201	return $data_dump->{report};	203	return $data_dump->{report} \|\| {};
202	}	204	}
203		205
204	=head3 additional_report	206	=head3 additional_report
Lines 256-261 sub type_to_class_mapping { Link Here
256	batch_authority_record_modification => 'Koha::BackgroundJob::BatchUpdateAuthority',	258	batch_authority_record_modification => 'Koha::BackgroundJob::BatchUpdateAuthority',
257	batch_biblio_record_deletion => 'Koha::BackgroundJob::BatchDeleteBiblio',	259	batch_biblio_record_deletion => 'Koha::BackgroundJob::BatchDeleteBiblio',
258	batch_biblio_record_modification => 'Koha::BackgroundJob::BatchUpdateBiblio',	260	batch_biblio_record_modification => 'Koha::BackgroundJob::BatchUpdateBiblio',
		261	batch_item_record_deletion => 'Koha::BackgroundJob::BatchDeleteItem',
		262	batch_item_record_modification => 'Koha::BackgroundJob::BatchUpdateItem',
259	batch_hold_cancel => 'Koha::BackgroundJob::BatchCancelHold',	263	batch_hold_cancel => 'Koha::BackgroundJob::BatchCancelHold',
260	};	264	};
261	}	265	}




package Koha::BackgroundJob::BatchDeleteItem;

# This file is part of Koha.
#
# Koha is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# Koha is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Koha; if not, see <http://www.gnu.org/licenses>.

=head1 NAME

Koha::BackgroundJob::BatchDeleteItem - Background job derived class to process item deletion in batch

=cut

use Modern::Perl;
use JSON qw( encode_json decode_json );
use List::MoreUtils qw( uniq );
use Try::Tiny;

use Koha::BackgroundJobs;
use Koha::DateUtils qw( dt_from_string );

use base 'Koha::BackgroundJob';

=head1 API

=head2 Class methods

=head3 job_type

Return the job type 'batch_item_record_deletion'.

=cut

sub job_type {
    return 'batch_item_record_deletion';
}

=head3 process

    Koha::BackgroundJobs->find($id)->process(
        {
            record_ids => \@itemnumbers,
            deleted_biblios => 0|1,
        }
    );

Will delete all the items that have been passed for deletion.

When deleted_biblios is passed, if we deleted the last item of a biblio,
the bibliographic record will be deleted as well.

The search engine's index will be updated according to the changes made
to the deleted bibliographic recods.

The generated report will be:
  {
    deleted_itemnumbers => \@list_of_itemnumbers,
    not_deleted_itemnumbers => \@list_of_itemnumbers,
    deleted_biblionumbers=> \@list_of_biblionumbers,
  }

=cut

sub process {
    my ( $self, $args ) = @_;

    my $job_type = $args->{job_type};

    my $job = Koha::BackgroundJobs->find( $args->{job_id} );

    if ( !exists $args->{job_id} || !$job || $job->status eq 'cancelled' ) {
        return;
    }

    # FIXME If the job has already been started, but started again (worker has been restart for instance)
    # Then we will start from scratch and so double delete the same records

    my $job_progress = 0;
    $job->started_on(dt_from_string)->progress($job_progress)
      ->status('started')->store;

    my @record_ids     = @{ $args->{record_ids} };
    my $delete_biblios = $args->{delete_biblios};

    my $report = {
        total_records => scalar @record_ids,
        total_success => 0,
    };
    my @messages;
    my $schema = Koha::Database->new->schema;
    my ( @deleted_itemnumbers, @not_deleted_itemnumbers,
        @deleted_biblionumbers );

    try {
        my $schema = Koha::Database->new->schema;
        $schema->txn_do(
            sub {
                my (@biblionumbers);
                for my $record_id ( sort { $a <=> $b } @record_ids ) {

                    last if $job->get_from_storage->status eq 'cancelled';

                    my $item = Koha::Items->find($record_id) || next;

                    my $return = $item->safe_delete;
                    unless ( ref($return) ) {

                        # FIXME Do we need to rollback the whole transaction if a deletion failed?
                        push @not_deleted_itemnumbers, $item->itemnumber;
                        push @messages,
                          {
                            type         => 'error',
                            code         => 'item_not_deleted',
                            itemnumber   => $item->itemnumber,
                            biblionumber => $item->biblionumber,
                            barcode      => $item->barcode,
                            title        => $item->biblio->title,
                            reason       => $return,
                          };

                        next;
                    }

                    push @deleted_itemnumbers, $item->itemnumber;
                    push @biblionumbers,       $item->biblionumber;

                    $report->{total_success}++;
                    $job->progress( ++$job_progress )->store;
                }

                # If there are no items left, delete the biblio
                if ( $delete_biblios && @biblionumbers ) {
                    for my $biblionumber ( uniq @biblionumbers ) {
                        my $items_count =
                          Koha::Biblios->find($biblionumber)->items->count;
                        if ( $items_count == 0 ) {
                            my $error = C4::Biblio::DelBiblio( $biblionumber,
                                { skip_record_index => 1 } );
                            unless ($error) {
                                push @deleted_biblionumbers, $biblionumber;
                            }
                        }
                    }

                    if (@deleted_biblionumbers) {
                        my $indexer = Koha::SearchEngine::Indexer->new(
                            { index => $Koha::SearchEngine::BIBLIOS_INDEX } );

                        $indexer->index_records( \@deleted_biblionumbers,
                            'recordDelete', "biblioserver", undef );
                    }
                }
            }
        );
    }
    catch {

        warn $_;

        push @messages,
          {
            type  => 'error',
            code  => 'unknown',
            error => $_,
          };

        die "Something terrible has happened!"
          if ( $_ =~ /Rollback failed/ );    # Rollback failed
    };

    $report->{deleted_itemnumbers}     = \@deleted_itemnumbers;
    $report->{not_deleted_itemnumbers} = \@not_deleted_itemnumbers;
    $report->{deleted_biblionumbers}   = \@deleted_biblionumbers;

    my $job_data = decode_json $job->data;
    $job_data->{messages} = \@messages;
    $job_data->{report}   = $report;

    $job->ended_on(dt_from_string)->data( encode_json $job_data);
    $job->status('finished') if $job->status ne 'cancelled';
    $job->store;
}

=head3 enqueue

    Koha::BackgroundJob::BatchDeleteItem->new->enqueue(
        {
            record_ids => \@itemnumbers,
            deleted_biblios => 0|1,
        }
    );

Enqueue the job.

=cut

sub enqueue {
    my ( $self, $args ) = @_;

    # TODO Raise exception instead
    return unless exists $args->{record_ids};

    my @record_ids = @{ $args->{record_ids} };
    my $delete_biblios = @{ $args->{delete_biblios} || [] };

    $self->SUPER::enqueue(
        {
            job_size => scalar @record_ids,
            job_args => {
                record_ids     => \@record_ids,
                delete_biblios => $delete_biblios,
            }
        }
    );
}

1;




package Koha::BackgroundJob::BatchUpdateItem;

# This file is part of Koha.
#
# Koha is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# Koha is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Koha; if not, see <http://www.gnu.org/licenses>.

use Modern::Perl;
use JSON qw( encode_json decode_json );
use List::MoreUtils qw( uniq );
use Try::Tiny;

use MARC::Record;
use MARC::Field;

use C4::Biblio;
use C4::Items;

use Koha::BackgroundJobs;
use Koha::DateUtils qw( dt_from_string );
use Koha::SearchEngine::Indexer;
use Koha::Items;
use Koha::UI::Table::Builder::Items;

use base 'Koha::BackgroundJob';

=head1 NAME

Koha::BackgroundJob::BatchUpdateItem - Background job derived class to process item modification in batch

=head1 API

=head2 Class methods

=head3 job_type

Define the job type of this job: batch_item_record_modification

=cut

sub job_type {
    return 'batch_item_record_modification';
}

=head3 process

    Koha::BackgroundJobs->find($id)->process(
        {
            record_ids => \@itemnumbers,
            new_values => {
                itemnotes => $new_item_notes,
                k         => $k,
            },
            regex_mod => {
                itemnotes_nonpublic => {
                    search => 'foo',
                    replace => 'bar',
                    modifiers => 'gi',
                },
            },
            exclude_from_local_holds_priority => 1|0
        }
    );

Process the modification.

new_values allows to set a new value for given fields.
The key can be one of the item's column name, or one subfieldcode of a MARC subfields not linked with a Koha field.

regex_mod allows to modify existing subfield's values using a regular expression.

=cut

sub process {
    my ( $self, $args ) = @_;

    my $job = Koha::BackgroundJobs->find( $args->{job_id} );

    if ( !exists $args->{job_id} || !$job || $job->status eq 'cancelled' ) {
        return;
    }

    # FIXME If the job has already been started, but started again (worker has been restart for instance)
    # Then we will start from scratch and so double process the same records

    my $job_progress = 0;
    $job->started_on(dt_from_string)->progress($job_progress)
      ->status('started')->store;

    my @record_ids = @{ $args->{record_ids} };
    my $regex_mod  = $args->{regex_mod};
    my $new_values = $args->{new_values};
    my $exclude_from_local_holds_priority =
      $args->{exclude_from_local_holds_priority};

    my $report = {
        total_records            => scalar @record_ids,
        modified_itemitemnumbers => [],
        modified_fields          => 0,
    };

    try {
        my $schema = Koha::Database->new->schema;
        $schema->txn_do(
            sub {
                my ($results) =
                  Koha::Items->search( { itemnumber => \@record_ids } )
                  ->batch_update(
                    {
                        regex_mod  => $regex_mod,
                        new_values => $new_values,
                        exclude_from_local_holds_priority =>
                          $exclude_from_local_holds_priority,
                        callback => sub {
                            my ($progress) = @_;
                            $job->progress($progress)->store;
                        },
                    }
                  );
                $report->{modified_itemnumbers} = $results->{modified_itemnumbers};
                $report->{modified_fields}      = $results->{modified_fields};
            }
        );
    }
    catch {
        warn $_;
        die "Something terrible has happened!"
          if ( $_ =~ /Rollback failed/ );    # Rollback failed
    };

    my $job_data = decode_json $job->data;
    $job_data->{report} = $report;

    $job->ended_on(dt_from_string)->data( encode_json $job_data);
    $job->status('finished') if $job->status ne 'cancelled';
    $job->store;
}

=head3 enqueue

Enqueue the new job

=cut

sub enqueue {
    my ( $self, $args ) = @_;

    # TODO Raise exception instead
    return unless exists $args->{record_ids};

    my @record_ids = @{ $args->{record_ids} };

    $self->SUPER::enqueue(
        {
            job_size => scalar @record_ids,
            job_args => {%$args},
        }
    );
}

=head3 additional_report

Sent the infos to generate the table containing the details of the modified items.

=cut

sub additional_report {
    my ( $self, $args ) = @_;

    my $job = Koha::BackgroundJobs->find( $args->{job_id} );

    my $itemnumbers = $job->report->{modified_itemnumbers};
    my $items_table =
      Koha::UI::Table::Builder::Items->new( { itemnumbers => $itemnumbers } )
      ->build_table;

    return {
        items            => $items_table->{items},
        item_header_loop => $items_table->{headers},
    };
}

1;




use Koha::Exceptions::Item::Transfer;
use Koha::Item::Transfer::Limits;
use Koha::Item::Transfers;
use Koha::Item::Attributes;
use Koha::ItemTypes;
use Koha::Patrons;
use Koha::Plugins;


=head3 as_marc_field

    my $field = $item->as_marc_field;
    my $field = $item->as_marc_field({ [ mss => $mss ] });

This method returns a MARC::Field object representing the Koha::Item object
with the current mappings configuration.

=cut

sub as_marc_field {
    my ( $self ) = @_;

    my ( $itemtag, $itemtagsubfield) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );
    my $item_tag = $mss->{'items.itemnumber'}[0]->{tagfield};

    my $tagslib = C4::Biblio::GetMarcStructure( 1, $self->biblio->frameworkcode, { unsafe => 1 });

    my @subfields;

    my $item_field = $tagslib->{$itemtag};

    my $more_subfields = $self->additional_attributes->to_hashref;
    foreach my $subfield (
        sort {
               $a->{display_order} <=> $b->{display_order}
            || $a->{subfield} cmp $b->{subfield}
        } grep { ref($_) && %$_ } values %$item_field
    ){

        my $kohafield = $subfield->{kohafield};
        my $tagsubfield = $subfield->{tagsubfield};
        my $value;
        if ( defined $kohafield ) {
            next if $kohafield !~ m{^items\.}; # That would be weird!
            ( my $attribute = $kohafield ) =~ s|^items\.||;
            $value = $self->$attribute # This call may fail if a kohafield is not a DB column but we don't want to add extra work for that there
                if defined $self->$attribute and $self->$attribute ne '';
        } else {
            $value = $more_subfields->{$tagsubfield}
        }

        next unless defined $value
            and $value ne q{};
    }

        if ( $subfield->{repeatable} ) {
            my @values = split '\|', $value;
            push @subfields, ( $tagsubfield => $_ ) for @values;
        }
        else {
            push @subfields, ( $tagsubfield => $value );
        }

    }

    return unless @subfields;
        "$item_tag", ' ', ' ', @subfields
    ) if @subfields;

    return MARC::Field->new(
        "$itemtag", ' ', ' ', @subfields
    );
}

=head3 renewal_branchcode

    return $values;
}

=head3 additional_attributes

    my $attributes = $item->additional_attributes;
    $attributes->{k} = 'new k';
    $item->update({ more_subfields => $attributes->to_marcxml });

Returns a Koha::Item::Attributes object that represents the non-mapped
attributes for this item.

=cut

sub additional_attributes {
    my ($self) = @_;

    return Koha::Item::Attributes->new_from_marcxml(
        $self->more_subfields_xml,
    );
}

=head3 _set_found_trigger

    $self->_set_found_trigger




package Koha::Item::Attributes;

# This file is part of Koha.
#
# Koha is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# Koha is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Koha; if not, see <http://www.gnu.org/licenses>.

use Modern::Perl;
use MARC::Record;
use MARC::Field;
use List::MoreUtils qw( uniq );

use C4::Biblio;
use C4::Charset qw( StripNonXmlChars );

=head1 NAME

Koha::Item::Attributes - Class to represent the additional attributes of items.

Additional attributes are 'more subfields xml'

=head1 API

=head2 Class methods

=cut

=head3 new_from_marcxml

    my $attributes = Koha::Item::Attributes->new_from_marcxml( $item->more_subfield_xml );

Constructor that takes a MARCXML.

=cut

# FIXME maybe this needs to care about repeatable but don't from batchMod - To implement later?
sub new_from_marcxml {
    my ( $class, $more_subfields_xml ) = @_;

    my $self = {};
    if ($more_subfields_xml) {
        # FIXME MARC::Record->new_from_xml (vs MARC::Record::new_from_xml) does not return the correctly encoded subfield code (??)
        my $marc_more =
          MARC::Record::new_from_xml(
            C4::Charset::StripNonXmlChars($more_subfields_xml), 'UTF-8' );

        # use of tag 999 is arbitrary, and doesn't need to match the item tag
        # used in the framework
        my $field = $marc_more->field('999');
        my $more_subfields = [ uniq map { $_->[0] } $field->subfields ];
        for my $more_subfield (@$more_subfields) {
            my @s = $field->subfield($more_subfield);
            $self->{$more_subfield} = join '|', @s;
        }
    }
    return bless $self, $class;
}

=head3 new

Constructor

=cut

# FIXME maybe this needs to care about repeatable but don't from batchMod - To implement later?
sub new {
    my ( $class, $attributes ) = @_;

    my $self = $attributes;
    return bless $self, $class;
}

=head3 to_marcxml

    $attributes->to_marcxml;

    $item->more_subfields_xml( $attributes->to_marcxml );

Return the MARCXML representation of the attributes.

=cut

sub to_marcxml {
    my ( $self, $frameworkcode ) = @_;

    return unless keys %$self;

    my $tagslib =
      C4::Biblio::GetMarcStructure( 1, $frameworkcode, { unsafe => 1 } );

    my ( $itemtag, $itemtagsubfield ) =
      C4::Biblio::GetMarcFromKohaField("items.itemnumber");
    my @subfields;
    for my $tagsubfield (
        sort {
            $tagslib->{$itemtag}->{$a}->{display_order} <=> $tagslib->{$itemtag}->{$b}->{display_order}
              || $tagslib->{$itemtag}->{$a}->{subfield} cmp $tagslib->{$itemtag}->{$b}->{subfield}
        } keys %$self
      )
    {
        next
          if not defined $self->{$tagsubfield}
          or $self->{$tagsubfield} eq "";

        if ( $tagslib->{$itemtag}->{$tagsubfield}->{repeatable} ) {
            my @values = split '\|', $self->{$tagsubfield};
            push @subfields, ( $tagsubfield => $_ ) for @values;
        }
        else {
            push @subfields, ( $tagsubfield => $self->{$tagsubfield} );
        }
    }

    return unless @subfields;

    my $marc_more = MARC::Record->new();

    # use of tag 999 is arbitrary, and doesn't need to match the item tag
    # used in the framework
    $marc_more->append_fields(
        MARC::Field->new( '999', ' ', ' ', @subfields ) );
    $marc_more->encoding("UTF-8");
    return $marc_more->as_xml("USMARC");
}

=head3 to_hashref

    $attributes->to_hashref;

Returns the hashref representation of the attributes.

=cut

sub to_hashref {
    my ($self) = @_;
    return { map { $_ => $self->{$_} } keys %$self };
}

1;

Lines 18-27 package Koha::Items; Link Here

(-)a/Koha/Items.pm (+213 lines)
18	# along with Koha; if not, see <http://www.gnu.org/licenses>.	18	# along with Koha; if not, see <http://www.gnu.org/licenses>.
19		19
20	use Modern::Perl;	20	use Modern::Perl;
		21	use Array::Utils qw( array_minus );
		22	use List::MoreUtils qw( uniq );
21		23
		24	use C4::Context;
		25	use C4::Biblio qw( GetMarcStructure GetMarcFromKohaField );
22		26
23	use Koha::Database;	27	use Koha::Database;
		28	use Koha::SearchEngine::Indexer;
24		29
		30	use Koha::Item::Attributes;
25	use Koha::Item;	31	use Koha::Item;
26	use Koha::CirculationRules;	32	use Koha::CirculationRules;
27		33
Lines 149-154 sub filter_out_lost { Link Here
149	return $self->search( $params );	155	return $self->search( $params );
150	}	156	}
151		157
		158
152	=head3 move_to_biblio	159	=head3 move_to_biblio
153		160
154	$items->move_to_biblio($to_biblio);	161	$items->move_to_biblio($to_biblio);
Lines 171-176 sub move_to_biblio { Link Here
171	}	178	}
172	}	179	}
173		180
		181	=head3 batch_update
		182
		183	Koha::Items->search->batch_update
		184	{
		185	new_values => {
		186	itemnotes => $new_item_notes,
		187	k => $k,
		188	},
		189	regex_mod => {
		190	itemnotes_nonpublic => {
		191	search => 'foo',
		192	replace => 'bar',
		193	modifiers => 'gi',
		194	},
		195	},
		196	exclude_from_local_holds_priority => 1\|0,
		197	callback => sub {
		198	# increment something here
		199	},
		200	}
		201	);
		202
		203	Batch update the items.
		204
		205	Returns ( $report, $self )
		206	Report has 2 keys:
		207	* modified_itemnumbers - list of the modified itemnumbers
		208	* modified_fields - number of fields modified
		209
		210	Parameters:
		211
		212	=over
		213
		214	=item new_values
		215
		216	Allows to set a new value for given fields.
		217	The key can be one of the item's column name, or one subfieldcode of a MARC subfields not linked with a Koha field
		218
		219	=item regex_mod
		220
		221	Allows to modify existing subfield's values using a regular expression
		222
		223	=item exclude_from_local_holds_priority
		224
		225	Set the passed boolean value to items.exclude_from_local_holds_priority
		226
		227	=item callback
		228
		229	Callback function to call after an item has been modified
		230
		231	=back
		232
		233	=cut
		234
		235	sub batch_update {
		236	my ( $self, $params ) = @_;
		237
		238	my $regex_mod = $params->{regex_mod} \|\| {};
		239	my $new_values = $params->{new_values} \|\| {};
		240	my $exclude_from_local_holds_priority = $params->{exclude_from_local_holds_priority};
		241	my $callback = $params->{callback};
		242
		243	my (@modified_itemnumbers, $modified_fields);
		244	my $i;
245	while ( my $item = $self->next ) {
246
247	my $modified_holds_priority = 0;
248	if ( defined $exclude_from_local_holds_priority ) {
249	if(!defined $item->exclude_from_local_holds_priority \|\| $item->exclude_from_local_holds_priority != $exclude_from_local_holds_priority) {
250	$item->exclude_from_local_holds_priority($exclude_from_local_holds_priority)->store;
251	$modified_holds_priority = 1;
252	}
253	}
254
255	my $modified = 0;
256	my $new_values = {%$new_values}; # Don't modify the original
257
258	my $old_values = $item->unblessed;
259	if ( $item->more_subfields_xml ) {
260	$old_values = {
261	%$old_values,
262	%{$item->additional_attributes->to_hashref},
263	};
264	}
265
266	for my $attr ( keys %$regex_mod ) {
267	my $old_value = $old_values->{$attr};
268
269	next unless $old_value;
270
271	my $value = apply_regex(
272	{
273	%{ $regex_mod->{$attr} },
274	value => $old_value,
275	}
276	);
277
278	$new_values->{$attr} = $value;
279	}
280
281	for my $attribute ( keys %$new_values ) {
282	next if $attribute eq 'more_subfields_xml'; # Already counted before
283
284	my $old = $old_values->{$attribute};
285	my $new = $new_values->{$attribute};
286	$modified++
287	if ( defined $old xor defined $new )
288	\|\| ( defined $old && defined $new && $new ne $old );
289	}
290
291	{ # Dealing with more_subfields_xml
292
293	my $frameworkcode = $item->biblio->frameworkcode;
294	my $tagslib = C4::Biblio::GetMarcStructure( 1, $frameworkcode, { unsafe => 1 });
295	my ( $itemtag, $itemsubfield ) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );
296
297	my @more_subfield_tags = map {
298	(
299	ref($_)
300	&& %$_
301	&& !$_->{kohafield} # Get subfields that are not mapped
302	)
303	? $_->{tagsubfield}
304	: ()
305	} values %{ $tagslib->{$itemtag} };
306
307	my $more_subfields_xml = Koha::Item::Attributes->new(
308	{
309	map {
310	exists $new_values->{$_} ? ( $_ => $new_values->{$_} )
311	: exists $old_values->{$_}
312	? ( $_ => $old_values->{$_} )
313	: ()
314	} @more_subfield_tags
315	}
316	)->to_marcxml($frameworkcode);
317
318	$new_values->{more_subfields_xml} = $more_subfields_xml;
319
320	delete $new_values->{$_} for @more_subfield_tags; # Clean the hash
321
322	}
323
324	if ( $modified ) {
325	my $itemlost_pre = $item->itemlost;
326	$item->set($new_values)->store({skip_record_index => 1});
327
328	LostItem(
329	$item->itemnumber, 'batchmod', undef,
330	{ skip_record_index => 1 }
331	) if $item->itemlost
332	and not $itemlost_pre;
333
334	push @modified_itemnumbers, $item->itemnumber if $modified \|\| $modified_holds_priority;
335	$modified_fields += $modified + $modified_holds_priority;
336	}
337
338	if ( $callback ) {
339	$callback->(++$i);
340	}
341	}
342
343	if (@modified_itemnumbers) {
344	my @biblionumbers = uniq(
345	Koha::Items->search( { itemnumber => \@modified_itemnumbers } )
346	->get_column('biblionumber'));
347
348	my $indexer = Koha::SearchEngine::Indexer->new(
349	{ index => $Koha::SearchEngine::BIBLIOS_INDEX } );
350	$indexer->index_records( \@biblionumbers, 'specialUpdate',
351	"biblioserver", undef )
352	if @biblionumbers;
353	}
354
355	return ( { modified_itemnumbers => \@modified_itemnumbers, modified_fields => $modified_fields }, $self );
356	}
357
358	sub apply_regex { # FIXME Should be moved outside of Koha::Items
359	my ($params) = @_;
360	my $search = $params->{search};
361	my $replace = $params->{replace};
362	my $modifiers = $params->{modifiers} \|\| q{};
363	my $value = $params->{value};
364
365	my @available_modifiers = qw( i g );
366	my $retained_modifiers = q\|\|;
367	for my $modifier ( split //, $modifiers ) {
368	$retained_modifiers .= $modifier
369	if grep { /$modifier/ } @available_modifiers;
370	}
371	if ( $retained_modifiers =~ m/^(ig\|gi)$/ ) {
372	$value =~ s/$search/$replace/ig;
373	}
374	elsif ( $retained_modifiers eq 'i' ) {
375	$value =~ s/$search/$replace/i;
376	}
377	elsif ( $retained_modifiers eq 'g' ) {
378	$value =~ s/$search/$replace/g;
379	}
380	else {
381	$value =~ s/$search/$replace/;
382	}
383
384	return $value;
385	}
386
174		387
175	=head2 Internal methods	388	=head2 Internal methods
176		389




    my $prefill_with_default_values = $params->{prefill_with_default_values};
    my $branch_limit = $params->{branch_limit};
    my $default_branches_empty = $params->{default_branches_empty};
    my $readonly = $params->{readonly};

    my $item         = $self->{item};
    my $subfield     = $tagslib->{$tag}{$subfieldtag};

        };
    }

    # If we're on restricted editing, and our field is not in the list of subfields to allow,
    # then it is read-only
    $subfield_data{marc_value}->{readonly} = $readonly;
      C4::Context->preference('SubfieldsToAllowForRestrictedEditing');
    my $allowAllSubfields = (
        not defined $subfieldsToAllowForRestrictedEditing
          or $subfieldsToAllowForRestrictedEditing eq q||
    ) ? 1 : 0;
    my @subfieldsToAllow = split( / /, $subfieldsToAllowForRestrictedEditing );

# If we're on restricted editing, and our field is not in the list of subfields to allow,
# then it is read-only
    $subfield_data{marc_value}->{readonly} =
      (       not $allowAllSubfields
          and $restricted_edition
          and !grep { $tag . '$' . $subfieldtag eq $_ } @subfieldsToAllow )
      ? 1
      : 0;

    return \%subfield_data;
}

=head3 edit_form

    my $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblionumber, item => $current_item } )->edit_form(


=item subfields_to_allow

List of subfields to allow (value of syspref SubfieldsToAllowForRestrictedBatchmod or SubfieldsToAllowForRestrictedEditing)

=item ignore_not_allowed_subfields

If set, the subfields in subfields_to_allow will be ignored (ie. they will not be part of the subfield list.
If not set, the subfields in subfields_to_allow will be marked as readonly.

=item kohafields_to_ignore

List of subfields to ignore/skip


    my $restricted_edition = $params->{restricted_editition};
    my $subfields_to_prefill = $params->{subfields_to_prefill} || [];
    my $subfields_to_allow = $params->{subfields_to_allow} || [];
    my $ignore_not_allowed_subfields = $params->{ignore_not_allowed_subfields};
    my $kohafields_to_ignore = $params->{kohafields_to_ignore} || [];
    my $prefill_with_default_values = $params->{prefill_with_default_values};
    my $branch_limit = $params->{branch_limit};
    my $default_branches_empty = $params->{default_branches_empty};


            next if IsMarcStructureInternal($subfield);
            next if $subfield->{tab} ne "10";
            next if @$subfields_to_allow && !grep { $subfield->{kohafield} eq $_ } @$subfields_to_allow;
            next
              if grep { $subfield->{kohafield} && $subfield->{kohafield} eq $_ }
              @$kohafields_to_ignore;

            my $readonly;
            if (
                @$subfields_to_allow && !grep {
                    sprintf( "%s\$%s", $subfield->{tagfield}, $subfield->{tagsubfield} ) eq $_
                } @$subfields_to_allow
              )
            {

                next if $ignore_not_allowed_subfields;
                $readonly = 1 if $restricted_edition;
            }

            my @values = ();


                        prefill_with_default_values => $prefill_with_default_values,
                        branch_limit       => $branch_limit,
                        default_branches_empty => $default_branches_empty,
                        readonly           => $readonly
                    }
                );
                push @subfields, $subfield_data;




package Koha::UI::Table::Builder::Items;

# This file is part of Koha.
#
# Koha is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# Koha is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Koha; if not, see <http://www.gnu.org/licenses>.

use Modern::Perl;
use List::MoreUtils qw( uniq );
use C4::Biblio qw( GetMarcStructure GetMarcFromKohaField IsMarcStructureInternal );
use Koha::Items;

=head1 NAME

Koha::UI::Table::Builder::Items

Helper to build a table with a list of items with all their information.

Items' attributes that are mapped and not mapped will be listed in the table.

Only attributes that have been defined only once will be displayed (empty string is considered as not defined).

=head1 API

=head2 Class methods

=cut

=head3 new

    my $table = Koha::UI::Table::Builder::Items->new( { itemnumbers => \@itemnumbers } );

Constructor.

=cut

sub new {
    my ( $class, $params ) = @_;

    my $self;
    $self->{itemnumbers} = $params->{itemnumbers} || [];

    bless $self, $class;
    return $self;
}

=head3 build_table

    my $items_table = Koha::UI::Table::Builder::Items->new( { itemnumbers => \@itemnumbers } )
                                                     ->build_table;

    my $items   = $items_table->{items};
    my $headers = $items_table->{headers};

Build the headers and rows for the table.

Use it with:
    [% PROCESS items_table_batchmod headers => headers, items => items %]

=cut

sub build_table {
    my ( $self, $params ) = @_;

    my $items = Koha::Items->search( { itemnumber => $self->{itemnumbers} } );

    my @items;
    while ( my $item = $items->next ) {
        my $item_info = $item->columns_to_str;
        $item_info = {
            %$item_info,
            biblio         => $item->biblio,
            safe_to_delete => $item->safe_to_delete,
            holds          => $item->biblio->holds->count,
            item_holds     => $item->holds->count,
            is_checked_out => $item->checkout || 0,
        };
        push @items, $item_info;
    }

    $self->{headers} = $self->_build_headers( \@items );
    $self->{items}   = \@items;
    return $self;
}

=head2 Internal methods

=cut

=head3 _build_headers

Build the headers given the items' info.

=cut

sub _build_headers {
    my ( $self, $items ) = @_;

    my @witness_attributes = uniq map {
        my $item = $_;
        map { defined $item->{$_} && $item->{$_} ne "" ? $_ : () } keys %$item
    } @$items;

    my ( $itemtag, $itemsubfield ) =
      C4::Biblio::GetMarcFromKohaField("items.itemnumber");
    my $tagslib = C4::Biblio::GetMarcStructure(1);
    my $subfieldcode_attribute_mappings;
    for my $subfield_code ( keys %{ $tagslib->{$itemtag} } ) {

        my $subfield = $tagslib->{$itemtag}->{$subfield_code};

        next if IsMarcStructureInternal($subfield);
        next unless $subfield->{tab} eq 10;    # Is this really needed?

        my $attribute;
        if ( $subfield->{kohafield} ) {
            ( $attribute = $subfield->{kohafield} ) =~ s|^items\.||;
        }
        else {
            $attribute = $subfield_code;       # It's in more_subfields_xml
        }
        next unless grep { $attribute eq $_ } @witness_attributes;
        $subfieldcode_attribute_mappings->{$subfield_code} = $attribute;
    }

    return [
        map {
            {
                header_value  => $tagslib->{$itemtag}->{$_}->{lib},
                attribute     => $subfieldcode_attribute_mappings->{$_},
                subfield_code => $_,
            }
        } sort keys %$subfieldcode_attribute_mappings
    ];
}

1

Lines 509-515 my @witness_attributes = uniq map { Link Here

(-)a/cataloguing/additem.pl (-3 / +10 lines)
509	map { defined $item->{$_} && $item->{$_} ne "" ? $_ : () } keys %$item	509	map { defined $item->{$_} && $item->{$_} ne "" ? $_ : () } keys %$item
510	} @items;	510	} @items;
511		511
512	our ( $itemtagfield, $itemtagsubfield ) = &GetMarcFromKohaField("items.itemnumber");	512	our ( $itemtagfield, $itemtagsubfield ) = GetMarcFromKohaField("items.itemnumber");
513		513
514	my $subfieldcode_attribute_mappings;	514	my $subfieldcode_attribute_mappings;
515	for my $subfield_code ( keys %{ $tagslib->{$itemtagfield} } ) {	515	for my $subfield_code ( keys %{ $tagslib->{$itemtagfield} } ) {
Lines 561-572 if ( $nextop eq 'additem' && $prefillitem ) { Link Here
561	# Setting to 1 element if SubfieldsToUseWhenPrefill is empty to prevent all the subfields to be prefilled	561	# Setting to 1 element if SubfieldsToUseWhenPrefill is empty to prevent all the subfields to be prefilled
562	@subfields_to_prefill = split(' ', C4::Context->preference('SubfieldsToUseWhenPrefill')) \|\| ("");	562	@subfields_to_prefill = split(' ', C4::Context->preference('SubfieldsToUseWhenPrefill')) \|\| ("");
563	}	563	}
		564
		565	# Getting list of subfields to keep when restricted editing is enabled
		566	my @subfields_to_allow = $restrictededition ? split ' ', C4::Context->preference('SubfieldsToAllowForRestrictedEditing') : ();
		567
564	my $subfields =	568	my $subfields =
565	Koha::UI::Form::Builder::Item->new(	569	Koha::UI::Form::Builder::Item->new(
566	{ biblionumber => $biblionumber, item => $current_item } )->edit_form(	570	{ biblionumber => $biblionumber, item => $current_item } )->edit_form(
567	{	571	{
568	branchcode => $branchcode,	572	branchcode => $branchcode,
569	restricted_editition => $restrictededition,	573	restricted_editition => $restrictededition,
		574	(
		575	@subfields_to_allow
		576	? ( subfields_to_allow => \@subfields_to_allow )
		577	: ()
		578	),
570	(	579	(
571	@subfields_to_prefill	580	@subfields_to_prefill
572	? ( subfields_to_prefill => \@subfields_to_prefill )	581	? ( subfields_to_prefill => \@subfields_to_prefill )
Lines 595-602 $template->param( Link Here
595	subfields => $subfields,	604	subfields => $subfields,
596	itemnumber => $itemnumber,	605	itemnumber => $itemnumber,
597	barcode => $current_item->{barcode},	606	barcode => $current_item->{barcode},
598	itemtagfield => $itemtagfield,
599	itemtagsubfield => $itemtagsubfield,
600	op => $nextop,	607	op => $nextop,
601	popup => scalar $input->param('popup') ? 1: 0,	608	popup => scalar $input->param('popup') ? 1: 0,
602	C4::Search::enabled_staff_search_views,	609	C4::Search::enabled_staff_search_views,




[% END %]

[% BLOCK js %]
    <script>
        $("#add_bibs_to_list").change(function(){
            var selected = $("#add_bibs_to_list").find("option:selected");
            if ( selected.attr("class") == "shelf" ){
                var shelfnumber = selected.attr("value");
                var bibs = new Array();
                [% FOREACH message IN job.messages %]
                    [% IF message.code == 'biblio_modified' %]
                        bibs.push("biblionumber="+[% message.biblionumber | html %]);
                    [% END %]
                [% END %]
                var bibstring = bibs.join("&");
                window.open('/cgi-bin/koha/virtualshelves/addbybiblionumber.pl?shelfnumber='+shelfnumber+'&confirm=1&'+bibstring, 'popup', 'width=500,height=500,toolbar=false,scrollbars=yes,resizable=yes');
                return false;
            }
        });
    </script>
[% END %]




[% BLOCK report %]
    [% SET report = job.report %]
    [% IF report %]
        <div class="dialog message">
            [% IF report.deleted_itemnumbers.size %]
                <p>[% report.deleted_itemnumbers.size | html %] item(s) deleted.</p>
                [% IF report.deleted_biblionumbers.size %]
                    <p>[% report.deleted_biblionumbers.size | html %] record(s) deleted.</p>
                [% END %]
            [% ELSE %]
                No items deleted.
            [% END %]
        </div>

        [% IF report.not_deleted_itemnumbers.size %]
            <div class="dialog error">
                [% report.not_deleted_itemnumbers.size | html %] item(s) could not be deleted: [% FOREACH not_deleted_itemnumber IN not_deleted_itemnumbers %][% not_deleted_itemnumber.itemnumber | html %][% END %]
            </div>
        [% END %]

        [% IF job.status == 'cancelled' %]
            <div class="dialog error">
                The job has been cancelled before it finished.
                <a href="/cgi-bin/koha/tools/batchMod.pl" title="New batch item modification">New batch item modification</a>
            </div>
        [% END %]
    [% END %]
[% END %]

[% BLOCK detail %]
    [% FOR m IN job.messages %]
        <div class="dialog message">
            [% IF m.type == 'success' %]
                <i class="fa fa-check success"></i>
            [% ELSIF m.type == 'warning' %]
                <i class="fa fa-warning warn"></i>
            [% ELSIF m.type == 'error' %]
                <i class="fa fa-exclamation error"></i>
            [% END %]
            [% SWITCH m.code %]
                [% CASE 'item_not_deleted' %]
                    Item with barcode <a href="/cgi-bin/koha/catalogue/moredetail.pl?biblionumber=[% m.biblionumber | uri %]&itemnumber=[% m.itemnumber | uri %]">[% m.barcode | html %]</a> cannot be deleted:
                    [% SWITCH m.reason %]
                        [% CASE "book_on_loan" %]Item is checked out
                        [% CASE "not_same_branch" %]Item does not belong to your library
                        [% CASE "book_reserved" %]Item has a waiting hold
                        [% CASE "linked_analytics" %]Item has linked analytics
                        [% CASE "last_item_for_hold" %]Last item for bibliographic record with biblio-level hold on it
                        [% CASE %]Unknown reason '[% m.reason | html %]'
                    [% END %]
                [% CASE %]Unknown message '[% m.code | html %]'
            [% END %]
        </div>
    [% END %]
[% END %]

[% BLOCK js %]
[% END %]




[% BLOCK report %]
    [% SET report = job.report %]
    [% IF report %]
        <div class="dialog message">
            [% IF report.modified_itemnumbers.size %]
                [% report.modified_itemnumbers.size | html %] item(s) modified (with [% report.modified_fields | html %] field(s) modified).
            [% ELSE %]
                No items modified.
            [% END %]

            [% IF job.status == 'cancelled' %]The job has been cancelled before it finished.[% END %]
            <a href="/cgi-bin/koha/tools/batchMod.pl" title="New batch item modification">New batch item modification</a>
        </div>
    [% END %]
[% END %]

[% BLOCK detail %]
    [% FOR m IN job.messages %]
        <div class="dialog message">
            [% IF m.type == 'success' %]
                <i class="fa fa-check success"></i>
            [% ELSIF m.type == 'warning' %]
                <i class="fa fa-warning warn"></i>
            [% ELSIF m.type == 'error' %]
                <i class="fa fa-exclamation error"></i>
            [% END %]
            [% SWITCH m.code %]
            [% CASE %]Unknown message '[% m.code | html %]'
            [% END %]
        </div>
    [% END %]

    [% PROCESS items_table_batchmod headers => item_header_loop, items => items, display_columns_selection => 1 %]
[% END %]

[% BLOCK js %]
    [% Asset.js("js/pages/batchMod.js") | $raw %]
[% END %]




        [% END %]
    </ol>
[% END %]

[% BLOCK items_table_batchmod %]

    [% IF display_columns_selection %][%# Needs js/pages/batchMod.js %]
        [% IF checkboxes_edit OR checkboxes_delete %]
            <div id="toolbar">
                <a id="selectallbutton" href="#"><i class="fa fa-check"></i> Select all</a> | <a id="clearallbutton" href="#"><i class="fa fa-remove"></i> Clear all</a> | <a id="clearonloanbutton" href="#">Clear on loan</a>
            </div>
        [% END %]

        <div id="cataloguing_additem_itemlist">

            <p id="selections">
                <strong>Show/hide columns:</strong>
                <span class="selected">
                    <input type="checkbox" checked="checked" id="showall" />
                    <label for="showall">Show all columns</label>
                </span>
                <span>
                    <input type="checkbox" id="hideall" />
                    <label for="hideall">Hide all columns</label>
                </span>

                [% FOREACH header IN item_header_loop %]
                    <span class="selected">
                        <input id="checkheader[% loop.count | html %]" type="checkbox" checked="checked" />
                        <label for="checkheader[% loop.count | html %]">[% header.header_value | html %]</label>
                    </span>
                [% END %]
            </p> <!-- /#selections -->
        </div>
    [% END %]
    [% SET date_fields = [ 'dateaccessioned', 'onloan', 'datelastseen', 'datelastborrowed', 'replacementpricedate' ] %]
    <table id="itemst">
        <thead>
            <tr>
                [% IF checkboxes_edit OR checkboxes_delete %]
                    <th></th>
                [% END %]
                <th class="anti-the">Title</th>
                <th class="holds_count" title="Item holds / Total holds">Holds</th>
                [% FOREACH item_header IN headers %]
                    [% IF item_header.column_name %]
                        <th data-colname="[% item_header.column_name | html %]">
                    [% ELSE %]
                        <th>
                    [% END %]
                        [% item_header.header_value | html %]
                    </th>
                [% END %]
            </tr>
        </thead>
        <tbody>
            [% FOREACH item IN items %]
                [% SET can_be_edited = ! ( Koha.Preference('IndependentBranches') && ! logged_in_user && item.homebranch != Branches.GetLoggedInBranchcode() ) %]

                <tr>
                    [% IF checkboxes_edit %]
                        [% UNLESS can_be_edited%]
                            <td class="error">Cannot edit</td>
                        [% ELSE %]
                            <td>
                                <input type="checkbox" name="itemnumber" value="[% item.itemnumber | html %]" id="row[% item.itemnumber | html %]" checked="checked" data-is-onloan="[% item.is_checked_out | html %]" />
                            </td>
                        [% END %]
                    [% ELSIF checkboxes_delete %]
                        [% UNLESS can_be_edited %]
                            <td class="error">Cannot delete</td>
                        [% ELSE %]
                            [% IF item.safe_to_delete == 1 %]
                                <td><input type="checkbox" name="itemnumber" value="[% item.itemnumber | html %]" id="row[% item.itemnumber | html %]" checked="checked" /></td>
                            [% ELSE %]
                                [% SWITCH item.safe_to_delete%]
                                [% CASE "book_on_loan" %][% SET cannot_delete_reason = t("Item is checked out") %]
                                [% CASE "not_same_branch" %][% SET cannot_delete_reason = t("Item does not belong to your library") %]
                                [% CASE "book_reserved" %][% SET cannot_delete_reason = t("Item has a waiting hold") %]
                                [% CASE "linked_analytics" %][% SET cannot_delete_reason = t("Item has linked analytics") %]
                                [% CASE "last_item_for_hold" %][% SET cannot_delete_reason = t("Last item for bibliographic record with biblio-level hold on it") %]
                                [% CASE %][% SET cannot_delete_reason = t("Unknown reason") _ '(' _ item.safe_to_delete _ ')' %]
                                [% END %]

                                <td><input type="checkbox" name="itemnumber" value="[% item.itemnumber | html %]" id="row[% item.itemnumber | html %]" disabled="disabled" title="[% cannot_delete_reason | html %]"/></td>
                            [% END %]

                        [% END %]
                    [% END %]
                    <td>
                        <label for="row[% item.itemnumber | html %]">
                            <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% item.biblionumber | uri %]">
                                [% item.biblio.title | html %]
                            </a>
                            [% IF ( item.biblio.author ) %], by [% item.biblio.author | html %][% END %]
                        </label>
                    </td>
                    <td class="holds_count">
                        [% IF item.holds %]
                            [% IF item.item_holds %]
                                <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item.biblionumber | uri %]" title="Holds on this item: [% item.item_holds | html %] / Total holds on this record: [% item.holds | html -%]" >
                            [% ELSE %]
                                <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item.biblionumber | uri %]" title="No holds on this item / Total holds on this record: [% item.holds | html -%]" >
                            [% END %]
                        [% ELSE %]
                            [% IF item.holds %]
                                <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item.biblionumber | uri %]" title="Holds on this record: [% item.holds | html -%]" >
                            [% ELSE %]
                                <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item.biblionumber | uri %]" title="No holds on this record" >
                            [% END %]
                        [% END # /IF item.holds %]
                        [% IF item.holds %]
                            [% item.item_holds | html %]/[% item.holds | html %]
                        [% ELSE %]
                            [% item.holds | html %]
                        [% END %]
                        </a>
                    </td>
                    [% FOREACH header IN headers %]
                        [% SET attribute = header.attribute %]
                        [% IF header.attribute AND date_fields.grep('^' _ attribute _ '$').size %]
                            <td data-order="[% item.$attribute | html %]">[% item.$attribute | $KohaDates %]</td>
                        [% ELSE %]
                            <td>[% item.$attribute | html %]</td>
                        [% END %]
                    [% END %]

                </tr>
            [% END # /FOREACH items %]
        </tbody>
    </table> <!-- /#itemst -->

[% END %]




[% USE raw %]
[% USE KohaDates %]
[% USE Asset %]
[% USE KohaDates %]
[% SET footerjs = 1 %]

    [% END -%]
[% END %]
[% BLOCK show_job_type %]
    [% SWITCH job_type %]
    [% CASE 'batch_biblio_record_modification' %]
        Batch bibliographic record modification
    [% CASE 'batch_biblio_record_deletion' %]
        Batch bibliographic record record deletion
    [% CASE 'batch_authority_record_modification' %]
        Batch authority record modification
    [% CASE 'batch_authority_record_deletion' %]
        Batch authority record deletion
    [% CASE 'batch_item_record_modification' %]
        Batch item record modification
    [% CASE 'batch_item_record_deletion' %]
        Batch item record deletion
    [% CASE "batch_hold_cancel" %]
        Batch hold cancellation
    [% CASE %]Unknown job type '[% job_type | html %]'
    [% END %]

[% END %]
[% INCLUDE 'doc-head-open.inc' %]
<title>

            <li><label for="job_progress">Progress: </label>[% job.progress || 0 | html %] / [% job.size | html %]</li>
            <li>
                <label for="job_type">Type: </label>
                [% PROCESS show_job_type job_type => job.type %]
            </li>
            <li>
                <label for="job_enqueued_on">Queued: </label>

                    </td>
                    <td>[% job.progress || 0 | html %] / [% job.size | html %]</td>
                    <td>
                        [% PROCESS show_job_type job_type => job.type %]
                        [% CASE 'batch_biblio_record_modification' %]Batch bibliographic record modification
                        [% CASE 'batch_biblio_record_deletion' %]Batch bibliographic record record deletion
                        [% CASE 'batch_authority_record_modification' %]Batch authority record modification
                        [% CASE 'batch_authority_record_deletion' %]Batch authority record deletion
                        [% CASE "batch_hold_cancel" %]Batch hold cancellation
                        [% CASE %][% job.type | html %]
                        [% END %]
                    </td>
                    <td>[% job.enqueued_on | $KohaDates with_hours = 1 %]</td>
                    <td>[% job.started_on| $KohaDates with_hours = 1 %]</td>

                "sPaginationType": "full_numbers"
            }));

            [% IF op == 'view' %]
                [% PROCESS 'js' %]
            [% END %]
        });
    </script>
    [% IF op == 'view' %]
        [% PROCESS 'js' %]
    [% END %]
[% END %]

[% INCLUDE 'intranet-bottom.inc' %]

Lines 184-191 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/cataloguing/additem.tt (-2 lines)
184	</fieldset>	184	</fieldset>
185		185
186	[% ELSE %]	186	[% ELSE %]
187	<input type="hidden" name="tag" value="[% itemtagfield \| html %]" />
188	<input type="hidden" name="subfield" value="[% itemtagsubfield \| html %]" />
189	[% IF op != 'add_item' %]	187	[% IF op != 'add_item' %]
190	<input type="hidden" name="itemnumber" value="[% itemnumber \| html %]" />	188	<input type="hidden" name="itemnumber" value="[% itemnumber \| html %]" />
191	[% END %]	189	[% END %]




[% USE raw %]
[% USE KohaDates %]
[% USE Asset %]
[% SET footerjs = 1 %]
[% PROCESS 'i18n.inc' %]


<div class="main container-fluid">

    <h1>Batch item deletion</h1>

    [% FOREACH message IN messages %]
      [% IF message.type == 'success' %]
        <div class="dialog message">
      [% ELSIF message.type == 'warning' %]
        <div class="dialog alert">
      [% ELSIF message.type == 'error' %]
        <div class="dialog alert" style="margin:auto;">
      [% END %]
      [% IF message.code == 'cannot_enqueue_job' %]
          Cannot enqueue this job.
      [% END %]
      [% IF message.error %]
        (The error was: [% message.error | html %], see the Koha log file for more information).
      [% END %]
      </div>
    [% END %]


    [% UNLESS ( action ) %]


     <input type="hidden" name="biblionumber" id="biblionumber" value="[% biblionumber | html %]" />
     <input type="hidden" name="op" value="[% op | html %]" />
     <input type="hidden" name="searchid" value="[% searchid | html %]" />
     <input type="hidden" name="uploadedfileid" id="uploadedfileid" value="" />
     <input type="hidden" name="completedJobID" id="completedJobID" value="" />
     <input type="hidden" name="src" id="src" value="[% src | html %]" />
     [% IF biblionumber %]
        <input type="hidden" name="biblionumber" id="biblionumber" value="[% biblionumber | html %]" />
     [% END %]

[% IF items.size %]
    [% PROCESS items_table_batchmod headers => item_header_loop, items => items, checkboxes_delete => 1, display_columns_selection => 1 %]
    <div id="cataloguing_additem_itemlist">

    <p id="selections"><strong>Show/hide columns:</strong> <span class="selected"><input type="checkbox" checked="checked" id="showall"/><label for="showall">Show all columns</label></span> <span><input type="checkbox" id="hideall"/><label for="hideall">Hide all columns</label></span>
        [% FOREACH item_header_loo IN item_header_loop %]
        <span class="selected"><input id="checkheader[% loop.count | html %]" type="checkbox" checked="checked" /> <label for="checkheader[% loop.count | html %]">[% item_header_loo.header_value | html %]</label> </span>
        [% END %]
    </p>

        <table id="itemst">
            <thead>
            <tr>
                [% IF ( show ) %]<th>&nbsp;</th>[% END %]
                <th class="anti-the">Title</th>
                <th class="holds_count" title="Item holds / Total holds">Holds</th>
                [% FOREACH item_header_loo IN item_header_loop %]
                <th> [% item_header_loo.header_value | html %] </th>
                [% END %]
            </tr>
            </thead>
            <tbody>
            [% FOREACH item_loo IN item_loop %]
              <tr>
                [% IF show %]
                  [% IF item_loo.nomod %]
                    <td class="error">Cannot delete</td>
                [% ELSE %]
                    [% IF item_loo.safe_to_delete == 1 %]
                        <td><input type="checkbox" name="itemnumber" value="[% item_loo.itemnumber | html %]" id="row[% item_loo.itemnumber | html %]" checked="checked" /></td>
                    [% ELSE %]
                        [% SWITCH item_loo.safe_to_delete%]
                        [% CASE "book_on_loan" %][% SET cannot_delete_reason = t("Item is checked out") %]
                        [% CASE "not_same_branch" %][% SET cannot_delete_reason = t("Item does not belong to your library") %]
                        [% CASE "book_reserved" %][% SET cannot_delete_reason = t("Item has a waiting hold") %]
                        [% CASE "linked_analytics" %][% SET cannot_delete_reason = t("Item has linked analytics") %]
                        [% CASE "last_item_for_hold" %][% SET cannot_delete_reason = t("Last item for bibliographic record with biblio-level hold on it") %]
                        [% CASE %][% SET cannot_delete_reason = t("Unknown reason") _ '(' _ item_loo.safe_to_delete _ ')' %]
                        [% END %]

                        <td><input type="checkbox" name="itemnumber" value="[% item_loo.itemnumber | html %]" id="row[% item_loo.itemnumber | html %]" disabled="disabled" title="[% cannot_delete_reason | html %]"/></td>
                    [% END %]
                  [% END %]
                [% ELSE %]
                  <td>&nbsp;</td>
                [% END %]
                <td>
                    <label for="row[% item_loo.itemnumber | html %]">
                        <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% item_loo.biblionumber | uri %]">
                            [% item_loo.title | html %]
                        </a>
                        [% IF ( item_loo.author ) %], by [% item_loo.author | html %][% END %]
                    </label>
                </td>
                <td class="holds_count">
                    [% IF item_loo.holds %]
                        [% IF item_loo.item_holds %]
                            <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item_loo.biblionumber | uri %]" title="Holds on this item: [% item_loo.item_holds | html %] / Total holds on this record: [% item_loo.holds | html -%]" >
                        [% ELSE %]
                            <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item_loo.biblionumber | uri %]" title="No holds on this item / Total holds on this record: [% item_loo.holds | html -%]" >
                        [% END %]
                    [% ELSE %]
                        [% IF item_loo.holds %]
                            <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item_loo.biblionumber | uri %]" title="Holds on this record: [% item_loo.holds | html -%]" >
                        [% ELSE %]
                            <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item_loo.biblionumber | uri %]" title="No holds on this record" >
                        [% END %]
                    [% END %]
                                [% IF item_loo.holds %]
                                    [% item_loo.item_holds | html %]/[% item_loo.holds | html %]
                                [% ELSE %]
                                    [% item_loo.holds | html %]
                                [% END %]
                            </a>
                </td>
            [% FOREACH item_valu IN item_loo.item_value %] <td>[% item_valu.field | html %]</td>
                    [% END %] </tr>
            [% END %]
            </tbody>
        </table>
    </div>
[% END %]

[% IF ( simple_items_display ) %]

    [% END %]
[% END %]

    [% IF ( itemresults ) %]
        <div id="cataloguing_additem_newitem">
         <input type="hidden" name="op" value="[% op | html %]" />
         <p>This will delete [% IF ( too_many_items_display ) %]all the[% ELSE %]the selected[% END %] items.</p>

    </form>
    [% END %]


    [% IF op == 'enqueued' %]
        <div class="dialog alert">
            At least one item blocked the deletion. The operation rolled back and nothing happened!
        </div>
    [% ELSE %]
        <div class="dialog message">
          <p>The job has been enqueued! It will be processed as soon as possible.</p>
          <p><a href="/cgi-bin/koha/admin/background_jobs.pl?op=view&id=[% job_id | uri %]" title="View detail of the enqueued job">View detail of the enqueued job</a>
          | <a href="/cgi-bin/koha/tools/batchMod.pl?del=1" title="New batch item deletion">New batch item deletion</a></p>
        </div>

        <fieldset class="action">
            [% IF src == 'CATALOGUING' # from catalogue/detail.pl > Delete items in a batch%]
                [% IF searchid %]
                    <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% biblionumber | uri %]&searchid=[% searchid | uri %]">Return to the record</a>
                        <div id="previous_search_link"></div>
                    [% END %]
                    <a href="/cgi-bin/koha/cataloguing/addbooks.pl">Return to the cataloging module</a>
                [% ELSE %]
                    <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% biblionumber | uri %]">Return to the record</a>
                        <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% biblionumber | uri %]&searchid=[% searchid | uri %]">Return to the record</a>
                    [% ELSE %]
                        <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% biblionumber | uri %]">Return to the record</a>
                    [% END %]
                [% END %]
            [% ELSIF src %]
                <a href="[% src | url %]">Return to where you were</a>
            [% ELSE %]
                <a href="/cgi-bin/koha/tools/batchMod.pl?del=1">Return to batch item deletion</a>
            [% END %]
        </fieldset>
    [% END %]
    [% IF ( not_deleted_items ) %]
    <div style="width:55%;margin:auto;">
        <p>[% not_deleted_items | html %] item(s) could not be deleted: [% FOREACH not_deleted_itemnumber IN not_deleted_itemnumbers %][% not_deleted_itemnumber.itemnumber | html %][% END %]</p>
    [% IF ( not_deleted_loop ) %]
    <table id="itemst">
        <thead>
            <tr>
            <th>Itemnumber</th>
            <th>Barcode</th>
            <th>Reason</th>
            </tr>
        </thead>
        <tbody>
            [% FOREACH not_deleted_loo IN not_deleted_loop %]
            <tr>
                <td>[% not_deleted_loo.itemnumber | html %]</td>
                <td>[% IF ( CAN_user_editcatalogue_edit_items ) %]<a href="/cgi-bin/koha/cataloguing/additem.pl?op=edititem&amp;biblionumber=[% not_deleted_loo.biblionumber | uri %]&amp;itemnumber=[% not_deleted_loo.itemnumber | uri %]">[% not_deleted_loo.barcode | html %]</a>[% ELSE %][% not_deleted_loo.barcode | html %][% END %]</td>
                <td>
                    [% SWITCH not_deleted_loo.reason %]
                    [% CASE "book_on_loan" %][% SET cannot_delete_reason = t("Item is checked out") %]
                    [% CASE "not_same_branch" %][% SET cannot_delete_reason = t("Item does not belong to your library") %]
                    [% CASE "book_reserved" %][% SET cannot_delete_reason = t("Item has a waiting hold") %]
                    [% CASE "linked_analytics" %][% SET cannot_delete_reason = t("Item has linked analytics") %]
                    [% CASE "last_item_for_hold" %][% SET cannot_delete_reason = t("Last item for bibliographic record with biblio-level hold on it") %]
                    [% CASE %][% SET cannot_delete_reason = t("Unknown reason") _ '(' _ can_be_deleted _ ')' %]
                    [% END %]
                    [% cannot_delete_reason | html %]
                </td>
            </tr>
            [% END %]
        </tbody>
        </table>
    [% END %]
    </div>
    [% END %]

    <p>
        [% IF src == 'CATALOGUING' # from catalogue/detail.pl > Delete items in a batch%]
            [% IF biblio_deleted %]
                <a class="btn btn-default" href="/cgi-bin/koha/cataloguing/addbooks.pl"><i class="fa fa-check-square-o"></i> Return to the cataloging module</a>
            [% ELSIF searchid %]
               <a class="btn btn-default" href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% biblionumber | uri %]&searchid=[% searchid | uri %]"><i class="fa fa-check-square-o"></i> Return to the record</a>
            [% ELSE %]
               <a class="btn btn-default" href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% biblionumber | uri %]"><i class="fa fa-check-square-o"></i> Return to the record</a>
            [% END %]
        [% ELSIF src %]
           <a class="btn btn-default" href="[% src | url %]"><i class="fa fa-check-square-o"></i> Return to where you were</a>
        [% ELSE %]
           <a class="btn btn-default" href="/cgi-bin/koha/tools/batchMod.pl?del=1"><i class="fa fa-check-square-o"></i> Return to batch item deletion</a>
        [% END %]
    </p>
[% END %]
    </div>

[% MACRO jsinclude BLOCK %]

    [% Asset.js("js/pages/batchMod.js") | $raw %]
    [% Asset.js("js/browser.js") | $raw %]
    <script>
        // Prepare array of all column headers, incrementing each index by
        // two to accommodate control and title columns
        var allColumns = new Array([% FOREACH item_header_loo IN item_header_loop %]'[% loop.count | html %]'[% UNLESS ( loop.last ) %],[% END %][% END %]);
        for( x=0; x<allColumns.length; x++ ){
          allColumns[x] = Number(allColumns[x]) + 2;
        }
        $(document).ready(function(){
            $("#mainformsubmit").on("click",function(){
                return submitBackgroundJob(this.form);
            });
        });

        [% IF searchid %]
            browser = KOHA.browser('[% searchid | html %]');
            browser.show_back_link();




[% USE raw %]
[% USE Asset %]
[% USE Koha %]
[% USE KohaDates %]
[% SET footerjs = 1 %]
[% INCLUDE 'doc-head-open.inc' %]
<title>Batch item modification &rsaquo; Tools &rsaquo; Koha</title>


    <div class="main container-fluid">

        <h1>Batch item modification</h1>
        [% IF op == 'enqueued' %]
        [% ELSE %]
            <h1>Batch item modification results</h1>
            <div class="dialog message">
              <p>The job has been enqueued! It will be processed as soon as possible.</p>
              <p><a href="/cgi-bin/koha/admin/background_jobs.pl?op=view&id=[% job_id | uri %]" title="View detail of the enqueued job">View detail of the enqueued job</a>
              | <a href="/cgi-bin/koha/tools/batchMod.pl" title="New batch item modification">New batch item modification</a></p>
            </div>

            <fieldset class="action">
                [% IF src == 'CATALOGUING' # from catalogue/detail.pl > Edit items in a batch%]
                    [% IF searchid %]
                        <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% biblionumber | uri %]&searchid=[% searchid | uri %]">Return to the record</a>
                        [% ELSE %]
                            <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% biblionumber | uri %]">Return to the record</a>
                        [% END %]
                    [% ELSIF src %]
                        <a href="[% src | url %]">Return to where you were</a>
                    [% ELSE %]
                        <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% biblionumber | uri %]">Return to the record</a>
                    [% END %]
                [% ELSIF src %]
                    <a href="[% src | url %]">Return to where you were</a>
                [% ELSE %]
                    <a href="/cgi-bin/koha/tools/batchMod.pl">Return to batch item modification</a>
                [% END %]
            </fieldset>
        [% END %]

        [% FOREACH message IN messages %]
          [% IF message.type == 'success' %]
            <div class="dialog message">
          [% ELSIF message.type == 'warning' %]
            <div class="dialog alert">
          [% ELSIF message.type == 'error' %]
            <div class="dialog alert" style="margin:auto;">
          [% END %]
          [% IF message.code == 'cannot_enqueue_job' %]
              Cannot enqueue this job.
          [% END %]
          [% IF message.error %]
            (The error was: [% message.error | html %], see the Koha log file for more information).
          [% END %]
          </div>
        [% END %]


        [% IF ( barcode_not_unique ) %]
            <div class="dialog alert">

                <input type="hidden" name="biblionumber" id="biblionumber" value="[% biblionumber | html %]" />
            [% END %]

            [% IF items.size %]
                    [% PROCESS items_table_batchmod headers => item_header_loop, items => items, checkboxes_edit => 1, display_columns_selection => 1 %]
            [% END %]
                        <a id="selectallbutton" href="#"><i class="fa fa-check"></i> Select all</a> | <a id="clearallbutton" href="#"><i class="fa fa-remove"></i> Clear all</a> | <a id="clearonloanbutton" href="#">Clear on loan</a>
                    </div>
                [% END %]

                <div id="cataloguing_additem_itemlist">

                    <p id="selections">
                        <strong>Show/hide columns:</strong>
                        <span class="selected">
                            <input type="checkbox" checked="checked" id="showall" />
                            <label for="showall">Show all columns</label>
                        </span>
                        <span>
                            <input type="checkbox" id="hideall" />
                            <label for="hideall">Hide all columns</label>
                        </span>

                        [% FOREACH item_header_loo IN item_header_loop %]
                            <span class="selected">
                                <input id="checkheader[% loop.count | html %]" type="checkbox" checked="checked" />
                                <label for="checkheader[% loop.count | html %]">[% item_header_loo.header_value | html %]</label>
                            </span>
                        [% END %]
                    </p> <!-- /#selections -->

                    <table id="itemst">
                        <thead>
                            <tr>
                                <th>&nbsp;</th>
                                <th class="anti-the">Title</th>
                                <th class="holds_count" title="Item holds / Total holds">Holds</th>
                                [% FOREACH item_header_loo IN item_header_loop %]
                                    <th> [% item_header_loo.header_value | html %] </th>
                                [% END %]
                            </tr>
                        </thead>
                        <tbody>
                            [% FOREACH item_loo IN item_loop %]
                                <tr>
                                    [% IF show %]
                                        [% IF item_loo.nomod %]
                                            <td class="error">Cannot edit</td>
                                        [% ELSE %]
                                            <td>
                                                <input type="checkbox" name="itemnumber" value="[% item_loo.itemnumber | html %]" id="row[% item_loo.itemnumber | html %]" checked="checked" data-is-onloan="[% item_loo.onloan | html %]" />
                                            </td>
                                        [% END %]
                                    [% ELSE %]
                                        <td>&nbsp;</td>
                                    [% END %]
                                    <td>
                                        <label for="row[% item_loo.itemnumber | html %]">
                                            <a href="/cgi-bin/koha/catalogue/detail.pl?biblionumber=[% item_loo.biblionumber | uri %]">
                                                [% item_loo.title | html %]
                                            </a>
                                            [% IF ( item_loo.author ) %], by [% item_loo.author | html %][% END %]
                                        </label>
                                    </td>
                                    <td class="holds_count">
                                        [% IF item_loo.holds %]
                                            [% IF item_loo.item_holds %]
                                                <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item_loo.biblionumber | uri %]" title="Holds on this item: [% item_loo.item_holds | html %] / Total holds on this record: [% item_loo.holds | html -%]" >
                                            [% ELSE %]
                                                <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item_loo.biblionumber | uri %]" title="No holds on this item / Total holds on this record: [% item_loo.holds | html -%]" >
                                            [% END %]
                                        [% ELSE %]
                                            [% IF item_loo.holds %]
                                                <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item_loo.biblionumber | uri %]" title="Holds on this record: [% item_loo.holds | html -%]" >
                                            [% ELSE %]
                                                <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% item_loo.biblionumber | uri %]" title="No holds on this record" >
                                            [% END %]
                                        [% END # /IF item_loo.holds %]
                                        [% IF item_loo.holds %]
                                            [% item_loo.item_holds | html %]/[% item_loo.holds | html %]
                                        [% ELSE %]
                                            [% item_loo.holds | html %]
                                        [% END %]
                                        </a>
                                    </td>
                                    [% FOREACH item_valu IN item_loo.item_value %]
                                        <td>
                                            [% item_valu.field | html %]
                                        </td>
                                    [% END %]
                                </tr>
                            [% END # /FOREACH item_loo %]
                        </tbody>
                    </table> <!-- /#itemst -->
                </div> <!-- /#cataloguing_additem_itemlist -->
            [% END # /IF item_loop %]

            [% IF ( simple_items_display || job_completed ) %]
                [% IF ( too_many_items_display ) %]

                        <a class="btn btn-default" href="/cgi-bin/koha/tools/batchMod.pl"><i class="fa fa-check-square-o"></i> Return to batch item modification</a>
                    [% END %]
                </fieldset> <!-- /.action -->
            [% END %]
        </form>

    [% MACRO jsinclude BLOCK %]




var date = new Date();
date.setTime(date.getTime() + (365 * 24 * 60 * 60 * 1000));

function guess_nb_cols() {
    // This is a bit ugly, we are trying to know if there are checkboxes in the first column of the table
    if ( $("#itemst tr:first th:first").html() == "" ) {
        // First header is empty, it's a checkbox
        return 3;
    } else {
        // First header is not empty, there are no checkboxes
        return 2;
    }
}

function hideColumns() {
    var valCookie = Cookies.get("showColumns");
    var nb_cols = guess_nb_cols();
    if (valCookie) {
        valCookie = valCookie.split("/");
        $("#showall").prop("checked", false).parent().removeClass("selected");
        for ( var i = 0; i < valCookie.length; i++ ) {
            if (valCookie[i] !== '') {
                var index = valCookie[i] - nb_cols;
                $("#itemst td:nth-child(" + valCookie[i] + "),#itemst th:nth-child(" + valCookie[i] + ")").toggle();
                $("#checkheader" + index).prop("checked", false).parent().removeClass("selected");
            }


function hideColumn(num) {
    $("#hideall,#showall").prop("checked", false).parent().removeClass("selected");
    var nb_cols = guess_nb_cols();
    var valCookie = Cookies.get("showColumns");
    // set the index of the table column to hide
    $("#" + num).parent().removeClass("selected");
    var hide = Number(num.replace("checkheader", "")) + nb_cols;
    // hide header and cells matching the index
    $("#itemst td:nth-child(" + hide + "),#itemst th:nth-child(" + hide + ")").toggle();
    // set or modify cookie with the hidden column's index

    $("#" + num).parent().addClass("selected");
    var valCookie = Cookies.get("showColumns");
    // set the index of the table column to hide
    var nb_cols = guess_nb_cols();
    var show = Number(num.replace("checkheader", "")) + nb_cols;
    // hide header and cells matching the index
    $("#itemst td:nth-child(" + show + "),#itemst th:nth-child(" + show + ")").toggle();
    // set or modify cookie with the hidden column's index

}

function showAllColumns() {
    var nb_cols = guess_nb_cols();
    $("#selections input:checkbox").each(function () {
        $(this).prop("checked", true);
    });
    $("#selections span").addClass("selected");
    $("#itemst td:nth-child("+nb_cols+"),#itemst tr th:nth-child("+nb_cols+")").nextAll().show();
    $.removeCookie("showColumns", { path: '/' });
    $("#hideall").prop("checked", false).parent().removeClass("selected");
}

function hideAllColumns() {
    var nb_cols = guess_nb_cols();
    $("#selections input:checkbox").each(function () {
        $(this).prop("checked", false);
    });
    $("#selections span").removeClass("selected");
    $("#itemst td:nth-child("+nb_cols+"),#itemst tr th:nth-child("+nb_cols+")").nextAll().hide();
    $("#hideall").prop("checked", true).parent().addClass("selected");
    var cookieString = allColumns.join("/");
    Cookies.set("showColumns", cookieString, { expires: date, path: '/' });

Lines 31-38 try { Link Here

(-)a/misc/background_jobs_worker.pl (+2 lines)
31	my @job_types = qw(	31	my @job_types = qw(
32	batch_biblio_record_modification	32	batch_biblio_record_modification
33	batch_authority_record_modification	33	batch_authority_record_modification
		34	batch_item_record_modification
34	batch_biblio_record_deletion	35	batch_biblio_record_deletion
35	batch_authority_record_deletion	36	batch_authority_record_deletion
		37	batch_item_record_deletion
36	batch_hold_cancel	38	batch_hold_cancel
37	);	39	);
38		40




subtest "as_marc_field() tests" => sub {

    my $mss = C4::Biblio::GetMarcSubfieldStructure( '' );
    my ( $itemtag, $itemtagsubfield) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );

    my @schema_columns = $schema->resultset('Item')->result_source->columns;
    my @mapped_columns = grep { exists $mss->{'items.'.$_} } @schema_columns;

    plan tests => 2 * (scalar @mapped_columns + 1) + 3;

    $schema->storage->txn_begin;



    is(
        $marc_field->tag,
        $itemtag,
        'Generated field set the right tag number'
    );



    is(
        $marc_field->tag,
        $itemtag,
        'Generated field set the right tag number'
    );


    my $unmapped_subfield = Koha::MarcSubfieldStructure->new(
        {
            frameworkcode => '',
            tagfield      => $itemtag,
            tagsubfield   => 'X',
        }
    )->store;

    $mss = C4::Biblio::GetMarcSubfieldStructure( '' );
    my @unlinked_subfields;
    push @unlinked_subfields, X => 'Something weird';
    $item->more_subfields_xml( C4::Items::_get_unlinked_subfields_xml( \@unlinked_subfields ) )->store;

    Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );
    Koha::MarcSubfieldStructures->search(
        { frameworkcode => '', tagfield => $itemtag } )
      ->update( { display_order => \['FLOOR( 1 + RAND( ) * 10 )'] } );

    $marc_field = $item->as_marc_field;

    my $tagslib = C4::Biblio::GetMarcStructure(1, '');
    my @subfields = $marc_field->subfields;
    my $result = all { defined $_->[1] } @subfields;
    ok( $result, 'There are no undef subfields' );
    my @ordered_subfields = sort {
            $tagslib->{$itemtag}->{ $a->[0] }->{display_order}
        <=> $tagslib->{$itemtag}->{ $b->[0] }->{display_order}
    } @subfields;
    is_deeply(\@subfields, \@ordered_subfields);

    is( scalar $marc_field->subfield('X'), 'Something weird', 'more_subfield_xml is considered' );

    $schema->storage->txn_rollback;
    Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );
};

subtest 'pickup_locations' => sub {




#!/usr/bin/perl

# This file is part of Koha.
#
# Koha is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# Koha is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Koha; if not, see <http://www.gnu.org/licenses>.

use Modern::Perl;
use Test::More tests=> 10;
use utf8;

use Koha::Database;
use Koha::Caches;

use C4::Biblio;
use Koha::Item::Attributes;
use Koha::MarcSubfieldStructures;

use t::lib::TestBuilder;

my $schema = Koha::Database->new->schema;
$schema->storage->txn_begin;

my $builder = t::lib::TestBuilder->new;
my $biblio = $builder->build_sample_biblio({ frameworkcode => '' });
my $item = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });

my $cache = Koha::Caches->get_instance;
$cache->clear_from_cache("MarcStructure-0-");
$cache->clear_from_cache("MarcStructure-1-");
$cache->clear_from_cache("default_value_for_mod_marc-");
$cache->clear_from_cache("MarcSubfieldStructure-");

# 952 $x $é $y are not linked with a kohafield
# $952$x $é repeatable
# $952$y is not repeatable
setup_mss();

$item->more_subfields_xml(undef)->store; # Shouldn't be needed, but we want to make sure
my $attributes = $item->additional_attributes;
is( ref($attributes), 'Koha::Item::Attributes' );
is( $attributes->to_marcxml, undef );
is_deeply($attributes->to_hashref, {});

my $some_marc_xml = q{<?xml version="1.0" encoding="UTF-8"?>
<collection
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.loc.gov/MARC21/slim http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd"
  xmlns="http://www.loc.gov/MARC21/slim">

<record>
  <leader>         a              </leader>
  <datafield tag="999" ind1=" " ind2=" ">
    <subfield code="x">value for x 1</subfield>
    <subfield code="x">value for x 2</subfield>
    <subfield code="y">value for y</subfield>
    <subfield code="é">value for é 1</subfield>
    <subfield code="é">value for é 2</subfield>
    <subfield code="z">value for z 1|value for z 2</subfield>
  </datafield>
</record>

</collection>};

$item->more_subfields_xml($some_marc_xml)->store;

$attributes = $item->additional_attributes;
is( ref($attributes), 'Koha::Item::Attributes' );
is( $attributes->{'x'}, "value for x 1|value for x 2");
is( $attributes->{'y'}, "value for y");
is( $attributes->{'é'}, "value for é 1|value for é 2");
is( $attributes->{'z'}, "value for z 1|value for z 2");

is( $attributes->to_marcxml, $some_marc_xml );
is_deeply(
    $attributes->to_hashref,
    {
        'x' => "value for x 1|value for x 2",
        'y' => "value for y",
        'é' => "value for é 1|value for é 2",
        'z' => "value for z 1|value for z 2",
    }
);

Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );

sub setup_mss {

    my ( $itemtag, $itemsubfield ) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => 'é',
        }
    )->delete;    # In case it exist already

    Koha::MarcSubfieldStructure->new(
        {
            frameworkcode => '',
            tagfield      => $itemtag,
            tagsubfield   => 'é',
            kohafield     => undef,
            repeatable    => 1,
            tab           => 10,
        }
    )->store;

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield      => $itemtag,
            tagsubfield   => [ 'x', 'y' ]
        }
    )->update( { kohafield => undef } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => [ 'x', 'é' ],
        }
    )->update( { repeatable => 1 } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => ['y'],
        }
    )->update( { repeatable => 0 } );

    my $i = 0;
    for my $sf ( qw( x y é z ) ) {
        Koha::MarcSubfieldStructures->search(
            { frameworkcode => '', tagfield => $itemtag, tagsubfield => $sf } )
          ->update( { display_order => $i++ } );
    }

}




#!/usr/bin/perl

# This file is part of Koha.
#
# Koha is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# Koha is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Koha; if not, see <http://www.gnu.org/licenses>.

use Modern::Perl;
use Test::More tests=> 7;
use utf8;

use Koha::Database;
use Koha::Caches;

use C4::Biblio;
use Koha::Item::Attributes;
use Koha::MarcSubfieldStructures;

use t::lib::TestBuilder;

my $schema = Koha::Database->new->schema;
$schema->storage->txn_begin;

my $builder = t::lib::TestBuilder->new;

Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );

# 952 $x $é $y are not linked with a kohafield
# $952$x $é repeatable
# $952$t is not repeatable
# 952$z is linked with items.itemnotes and is repeatable
# 952$t is linked with items.copynumber and is not repeatable
setup_mss();

my $biblio = $builder->build_sample_biblio({ frameworkcode => '' });
my $item = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });

my $items = Koha::Items->search({itemnumber => $item->itemnumber});

subtest 'MARC subfield linked with kohafield' => sub {
    plan tests => 9;

    $items->batch_update({
            new_values => {itemnotes => 'new note'}
        });
    $items->reset;

    $item = $item->get_from_storage;
    is( $item->itemnotes, 'new note' );
    is( $item->as_marc_field->subfield('t'), undef );

    is( $items->batch_update({
            new_values => {itemnotes=> 'another note'}
        })->count, 1, 'Can be chained');
    $items->reset;

    $items->batch_update({new_values => {itemnotes=> undef }})->reset;
    $item = $item->get_from_storage;
    is( $item->itemnotes, undef, "blank" );
    is( $item->as_marc_field->subfield('t'), undef, '' );

    $items->batch_update({new_values => {itemnotes=> 'new note', copynumber => 'new copynumber'}})->reset;
    $item = $item->get_from_storage;
    is( $item->itemnotes, 'new note', "multi" );
    is( $item->as_marc_field->subfield('z'), 'new note', '' );
    is( $item->copynumber, 'new copynumber', "multi" );
    is( $item->as_marc_field->subfield('t'), 'new copynumber', '' );
};

subtest 'More marc subfields (no linked)' => sub {
    plan tests => 1;

    $items->batch_update({new_values => {x => 'new xxx' }})->reset;
    is( $item->get_from_storage->as_marc_field->subfield('x'), 'new xxx' );
};

subtest 'repeatable' => sub {
    plan tests => 2;

    subtest 'linked' => sub {
        plan tests => 4;

        $items->batch_update({new_values => {itemnotes => 'new zzz 1|new zzz 2' }})->reset;
        is( $item->get_from_storage->itemnotes, 'new zzz 1|new zzz 2');
        is_deeply( [$item->get_from_storage->as_marc_field->subfield('z')], ['new zzz 1', 'new zzz 2'], 'z is repeatable' );

        $items->batch_update({new_values => {copynumber => 'new ttt 1|new ttt 2' }})->reset;
        is( $item->get_from_storage->copynumber, 'new ttt 1|new ttt 2');
        is_deeply( [$item->get_from_storage->as_marc_field->subfield('t')], ['new ttt 1|new ttt 2'], 't is not repeatable' );
    };

    subtest 'not linked' => sub {
        plan tests => 2;

        $items->batch_update({new_values => {x => 'new xxx 1|new xxx 2' }})->reset;
        is_deeply( [$item->get_from_storage->as_marc_field->subfield('x')], ['new xxx 1', 'new xxx 2'], 'i is repeatable' );

        $items->batch_update({new_values => {y => 'new yyy 1|new yyy 2' }})->reset;
        is_deeply( [$item->get_from_storage->as_marc_field->subfield('y')], ['new yyy 1|new yyy 2'], 'y is not repeatable' );
    };
};

subtest 'blank' => sub {
    plan tests => 5;

    $items->batch_update(
        {
            new_values => {
                itemnotes  => 'new notes 1|new notes 2',
                copynumber => 'new cn 1|new cn 2',
                x          => 'new xxx 1|new xxx 2',
                y          => 'new yyy 1|new yyy 2',

            }
        }
    )->reset;

    $items->batch_update(
        {
            new_values => {
                itemnotes  => undef,
                copynumber => undef,
                x          => undef,
            }
        }
    )->reset;

    $item = $item->get_from_storage;
    is( $item->itemnotes,                    undef );
    is( $item->copynumber,                   undef );
    is( $item->as_marc_field->subfield('x'), undef );
    is_deeply( [ $item->as_marc_field->subfield('y') ],
        ['new yyy 1|new yyy 2'] );

    $items->batch_update(
        {
            new_values => {
                y => undef,
            }
        }
    )->reset;

    is( $item->get_from_storage->more_subfields_xml, undef );

};

subtest 'regex' => sub {
    plan tests => 6;

    $items->batch_update(
        {
            new_values => {
                itemnotes  => 'new notes 1|new notes 2',
                copynumber => 'new cn 1|new cn 2',
                x          => 'new xxx 1|new xxx 2',
                y          => 'new yyy 1|new yyy 2',

            }
        }
    )->reset;

    my $re = {
        search    => 'new',
        replace   => 'awesome',
        modifiers => '',
    };
    $items->batch_update(
        {
            regex_mod =>
              { itemnotes => $re, copynumber => $re, x => $re, y => $re }
        }
    )->reset;
    $item = $item->get_from_storage;
    is( $item->itemnotes, 'awesome notes 1|new notes 2' );
    is_deeply(
        [ $item->as_marc_field->subfield('z') ],
        [ 'awesome notes 1', 'new notes 2' ],
        'z is repeatable'
    );

    is( $item->copynumber, 'awesome cn 1|new cn 2' );
    is_deeply( [ $item->as_marc_field->subfield('t') ],
        ['awesome cn 1|new cn 2'], 't is not repeatable' );

    is_deeply(
        [ $item->as_marc_field->subfield('x') ],
        [ 'awesome xxx 1', 'new xxx 2' ],
        'i is repeatable'
    );

    is_deeply(
        [ $item->as_marc_field->subfield('y') ],
        ['awesome yyy 1|new yyy 2'],
        'y is not repeatable'
    );
};

subtest 'encoding' => sub {
    plan tests => 1;

    $items->batch_update({
            new_values => { 'é' => 'new note é'}
        });
    $items->reset;

    $item = $item->get_from_storage;
    is( $item->as_marc_field->subfield('é'), 'new note é', );
};

subtest 'report' => sub {
    plan tests => 5;

    my $item_1 =
      $builder->build_sample_item( { biblionumber => $biblio->biblionumber } );
    my $item_2 =
      $builder->build_sample_item( { biblionumber => $biblio->biblionumber } );

    my $items = Koha::Items->search(
        { itemnumber => [ $item_1->itemnumber, $item_2->itemnumber ] } );

    my ($report) = $items->batch_update(
        {
            new_values => { itemnotes => 'new note' }
        }
    );
    $items->reset;
    is_deeply(
        $report,
        {
            modified_itemnumbers =>
              [ $item_1->itemnumber, $item_2->itemnumber ],
            modified_fields => 2
        }
    );

    ($report) = $items->batch_update(
        {
            new_values => { itemnotes => 'new note', copynumber => 'new cn' }
        }
    );
    $items->reset;

    is_deeply(
        $report,
        {
            modified_itemnumbers =>
              [ $item_1->itemnumber, $item_2->itemnumber ],
            modified_fields => 2
        }
    );

    $item_1->get_from_storage->update( { itemnotes => 'not new note' } );
    ($report) = $items->batch_update(
        {
            new_values => { itemnotes => 'new note', copynumber => 'new cn' }
        }
    );
    $items->reset;

    is_deeply(
        $report,
        {
            modified_itemnumbers => [ $item_1->itemnumber ],
            modified_fields      => 1
        }
    );

    ($report) = $items->batch_update(
        {
            new_values => { x => 'new xxx', y => 'new yyy' }
        }
    );
    $items->reset;

    is_deeply(
        $report,
        {
            modified_itemnumbers =>
              [ $item_1->itemnumber, $item_2->itemnumber ],
            modified_fields => 4
        }
    );

    my $re = {
        search    => 'new',
        replace   => 'awesome',
        modifiers => '',
    };

    $item_2->get_from_storage->update( { itemnotes => 'awesome note' } );
    ($report) = $items->batch_update(
        {
            regex_mod =>
              { itemnotes => $re, copynumber => $re, x => $re, y => $re }
        }
    );
    $items->reset;

    is_deeply(
        $report,
        {
            modified_itemnumbers =>
              [ $item_1->itemnumber, $item_2->itemnumber ],
            modified_fields => 7
        }
    );

};

Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );

sub setup_mss {

    my ( $itemtag, $itemsubfield ) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => 'é',
        }
    )->delete;    # In case it exist already

    Koha::MarcSubfieldStructure->new(
        {
            frameworkcode => '',
            tagfield      => $itemtag,
            tagsubfield   => 'é',
            kohafield     => undef,
            repeatable    => 1,
            tab           => 10,
        }
    )->store;

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield      => $itemtag,
            tagsubfield   => [ 'x', 'y' ]
        }
    )->update( { kohafield => undef } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => [ 'x', 'é' ],
        }
    )->update( { repeatable => 1 } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => ['t'],
        }
    )->update( { repeatable => 0 } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => ['z'],
        }
    )->update( { kohafield => 'items.itemnotes', repeatable => 1 } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
        }
    )->update( { display_order => \['FLOOR( 1 + RAND( ) * 10 )'] } );
}




#!/usr/bin/perl

# This file is part of Koha
#
# Koha is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# Koha is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Koha; if not, see <http://www.gnu.org/licenses>.

use Modern::Perl;
use Test::More tests => 6;
use utf8;

use List::MoreUtils qw( uniq );

use Koha::Libraries;
use Koha::MarcSubfieldStructures;
use Koha::UI::Form::Builder::Item;
use t::lib::TestBuilder;

my $schema = Koha::Database->new->schema;
$schema->storage->txn_begin;

my $builder = t::lib::TestBuilder->new;

my $cache = Koha::Caches->get_instance();
$cache->clear_from_cache("MarcStructure-0-");
$cache->clear_from_cache("MarcStructure-1-");
$cache->clear_from_cache("default_value_for_mod_marc-");
$cache->clear_from_cache("MarcSubfieldStructure-");

# 952 $x $é are not linked with a kohafield
# $952$x $é repeatable
# $952$t is not repeatable
# 952$z is linked with items.itemnotes and is repeatable
# 952$t is linked with items.copynumber and is not repeatable
setup_mss();

subtest 'authorised values' => sub {
    #plan tests => 1;

    my $biblio = $builder->build_sample_biblio({ value => {frameworkcode => ''}});
    my $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form;

    my @display_orders = uniq map { $_->{display_order} } @$subfields;
    is_deeply( \@display_orders, [sort {$a <=> $b} @display_orders], 'subfields are sorted by display order' );

    subtest 'normal AV' => sub {
        plan tests => 2;
        my ($subfield) =
          grep { $_->{kohafield} eq 'items.notforloan' } @$subfields;
        my $avs = Koha::AuthorisedValues->search( { category => 'NOT_LOAN' } );

        is_deeply(
            $subfield->{marc_value}->{values},
            [
                "",
                map    { $_->authorised_value }
                  sort { $a->lib cmp $b->lib }
                  $avs->as_list
            ],
            'AVs are sorted by lib and en empty option is created first'
        );
        is_deeply(
            $subfield->{marc_value}->{labels},
            {
                map    { $_->authorised_value => $_->lib }
                  sort { $a->lib cmp $b->lib }
                  $avs->as_list
            }
        );
    };

    subtest 'cn_source' => sub {
        plan tests => 2;
        my ( $subfield ) = grep { $_->{kohafield} eq 'items.cn_source' } @$subfields;
        is_deeply( $subfield->{marc_value}->{values}, [ '', 'ddc', 'lcc' ] );
        is_deeply(
            $subfield->{marc_value}->{labels},
            {
                ddc => "Dewey Decimal Classification",
                lcc => "Library of Congress Classification",
            }
        );
    };
    subtest 'branches' => sub {
        plan tests => 2;
        my ( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
        my $libraries = Koha::Libraries->search;
        is_deeply(
            $subfield->{marc_value}->{values},
            [ $libraries->get_column('branchcode') ]
        );
        is_deeply(
            $subfield->{marc_value}->{labels},
            { map { $_->branchcode => $_->branchname } $libraries->as_list }
        );
    };

    subtest 'itemtypes' => sub {
        plan tests => 2;
        my ($subfield) = grep { $_->{kohafield} eq 'items.itype' } @$subfields;
        my $itemtypes = Koha::ItemTypes->search;

        is_deeply(
            $subfield->{marc_value}->{values},
            [
                "",
                map    { $_->itemtype }
                  # We need to sort using uc or perl won't be case insensitive
                  sort { uc($a->translated_description) cmp uc($b->translated_description) }
                  $itemtypes->as_list
            ],
            "Item types should be sorted by description and an empty entries should be shown"
        );
        is_deeply( $subfield->{marc_value}->{labels},
            { map { $_->itemtype => $_->description } $itemtypes->as_list },
            'Labels should be correctly displayed'
        );
    };
};

subtest 'prefill_with_default_values' => sub {
    plan tests => 2;

    my $biblio = $builder->build_sample_biblio({ value => {frameworkcode => ''}});
    my $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form;


    my ($subfield) = grep { $_->{subfield} eq 'é' } @$subfields;
    is( $subfield->{marc_value}->{value}, '', 'no default value if prefill_with_default_values not passed' );

    $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form({ prefill_with_default_values => 1 });


    ($subfield) = grep { $_->{subfield} eq 'é' } @$subfields;
    is( $subfield->{marc_value}->{value}, 'ééé', 'default value should be set if prefill_with_default_values passed');


};

subtest 'branchcode' => sub {
    plan tests => 2;

    my $biblio = $builder->build_sample_biblio({ value => {frameworkcode => ''}});
    my $library = $builder->build_object({ class => 'Koha::Libraries' });
    my $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form;

    my ( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
    is( $subfield->{marc_value}->{default}, '', 'no library preselected if no branchcode passed');

    $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form({ branchcode => $library->branchcode });

    ( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
    is( $subfield->{marc_value}->{default}, $library->branchcode, 'the correct library should be preselected if branchcode is passed');
};

subtest 'default_branches_empty' => sub {
    plan tests => 2;

    my $biblio = $builder->build_sample_biblio({ value => {frameworkcode => ''}});
    my $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form;

    my ( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
    isnt( $subfield->{marc_value}->{values}->[0], "", 'No empty option for branches' );

    $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form({ default_branches_empty => 1 });

    ( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
    is( $subfield->{marc_value}->{values}->[0], "", 'empty option for branches if default_branches_empty passed' );
};

subtest 'kohafields_to_ignore' => sub {
    plan tests => 2;

    my $biblio =
      $builder->build_sample_biblio( { value => { frameworkcode => '' } } );
    my $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form;

    my ($subfield) = grep { $_->{kohafield} eq 'items.barcode' } @$subfields;
    isnt( $subfield, undef, 'barcode subfield should be in the subfield list' );

    $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )
      ->edit_form( { kohafields_to_ignore => ['items.barcode'] } );

    ($subfield) = grep { $_->{kohafield} eq 'items.barcode' } @$subfields;
    is( $subfield, undef,
        'barcode subfield should have not been built if passed to kohafields_to_ignore'
    );
};

subtest 'subfields_to_allow & ignore_not_allowed_subfields' => sub {
    plan tests => 6;

    my ( $tag_cn, $subtag_cn ) = C4::Biblio::GetMarcFromKohaField("items.itemcallnumber");
    my ( $tag_notes, $subtag_notes ) = C4::Biblio::GetMarcFromKohaField("items.itemnotes");
    my $biblio = $builder->build_sample_biblio( { value => { frameworkcode => '' } } );
    my $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form(
            {
                subfields_to_allow => [
                    sprintf( '%s$%s', $tag_cn,    $subtag_cn ),
                    sprintf( '%s$%s', $tag_notes, $subtag_notes )
                ]
            }
        );

    isnt( scalar(@$subfields), 2, "There are more than the 2 subfields we allowed" );
    my ($subfield) = grep { $_->{kohafield} eq 'items.itemcallnumber' } @$subfields;
    is( $subfield->{marc_value}->{readonly}, undef, "subfields to allowed are not marked as readonly" );
    ($subfield) = grep { $_->{kohafield} eq 'items.copynumber' } @$subfields;
    isnt( $subfield->{marc_value}->{readonly}, 1, "subfields that are not in the allow list are marked as readonly" );

    $subfields =
      Koha::UI::Form::Builder::Item->new(
        { biblionumber => $biblio->biblionumber } )->edit_form(
            {
                subfields_to_allow => [
                    sprintf( '%s$%s', $tag_cn,    $subtag_cn ),
                    sprintf( '%s$%s', $tag_notes, $subtag_notes )
                ],
                ignore_not_allowed_subfields => 1,
            }
        );

    is( scalar(@$subfields), 2, "With ignore_not_allowed_subfields, only the subfields to ignore are returned" );
    ($subfield) =
      grep { $_->{kohafield} eq 'items.itemcallnumber' } @$subfields;
    is( $subfield->{marc_value}->{readonly}, undef, "subfields to allowed are not marked as readonly" );
    ($subfield) = grep { $_->{kohafield} eq 'items.copynumber' } @$subfields;
    is( $subfield, undef, "subfield that is not in the allow list is not returned" );
};


$cache->clear_from_cache("MarcStructure-0-");
$cache->clear_from_cache("MarcStructure-1-");
$cache->clear_from_cache("default_value_for_mod_marc-");
$cache->clear_from_cache("MarcSubfieldStructure-");

sub setup_mss {

    my ( $itemtag, $itemsubfield ) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => 'é',
        }
    )->delete;    # In case it exist already

    Koha::MarcSubfieldStructure->new(
        {
            frameworkcode => '',
            tagfield      => $itemtag,
            tagsubfield   => 'é',
            kohafield     => undef,
            repeatable    => 1,
            defaultvalue  => 'ééé',
            tab           => 10,
        }
    )->store;

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield      => $itemtag,
            tagsubfield   => [ 'x' ]
        }
    )->update( { kohafield => undef } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => [ 'x', 'é' ],
        }
    )->update( { repeatable => 1 } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => ['t'],
        }
    )->update( { repeatable => 0 } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
            tagsubfield => ['z'],
        }
    )->update( { kohafield => 'items.itemnotes', repeatable => 1 } );

    Koha::MarcSubfieldStructures->search(
        {
            frameworkcode => '',
            tagfield => $itemtag,
        }
    )->update( { display_order => \['FLOOR( 1 + RAND( ) * 10 )'] } );
}





use C4::Auth qw( get_template_and_user haspermission );
use C4::Output qw( output_html_with_http_headers );
use C4::Circulation qw( barcodedecode );
    DelBiblio
    GetAuthorisedValueDesc
    GetMarcFromKohaField
    GetMarcStructure
    IsMarcStructureInternal
    TransformHtmlToXml
);
use C4::Items qw( GetItemsInfo Item2Marc ModItemFromMarc );
use C4::Circulation qw( barcodedecode LostItem IsItemIssued );
use C4::Context;
use C4::Koha;
use C4::BackgroundJob;
use C4::ClassSource qw( GetClassSources GetClassSource );
use MARC::File::XML;
use List::MoreUtils qw( uniq );
use Encode qw( encode_utf8 );

use Koha::Database;
use Koha::DateUtils qw( dt_from_string );
use Koha::Exceptions::Exception;
use Koha::AuthorisedValues;
use Koha::Biblios;
use Koha::DateUtils qw( dt_from_string );
use Koha::Items;
use Koha::ItemTypes;
use Koha::Patrons;
use Koha::Item::Attributes;
use Koha::BackgroundJob::BatchDeleteItem;
use Koha::BackgroundJob::BatchUpdateItem;
use Koha::UI::Form::Builder::Item;
use Koha::UI::Table::Builder::Items;

my $input = CGI->new;
my $dbh = C4::Context->dbh;

# In case user is a superlibrarian, edition is not restricted
$restrictededition = 0 if ($restrictededition != 0 && C4::Context->IsSuperLibrarian());

$template->param(del       => $del);

my $nextop="";
my $display_items;
my $items_display_hashref;
our $tagslib = &GetMarcStructure(1);

my $deleted_items = 0;     # Number of deleted items
my $deleted_records = 0;   # Number of deleted records ( with no items attached )
my $not_deleted_items = 0; # Number of items that could not be deleted
my @not_deleted;           # List of the itemnumbers that could not be deleted
my $modified_items = 0;    # Numbers of modified items
my $modified_fields = 0;   # Numbers of modified fields

my %cookies = parse CGI::Cookie($cookie);
my $sessionID = $cookies{'CGISESSID'}->value;

my @messages;

if ( $op eq "action" ) {

    if ($del) {
    my @tags      = $input->multi_param('tag');
    my @subfields = $input->multi_param('subfield');
    my @values    = $input->multi_param('field_value');
    my @searches  = $input->multi_param('regex_search');
    my @replaces  = $input->multi_param('regex_replace');
    my @modifiers = $input->multi_param('regex_modifiers');

    my $upd_biblionumbers;
    my $del_biblionumbers;
    if ( $del ) {
        try {
            my $params = {
                record_ids     => \@itemnumbers,
                delete_biblios => $del_records,
            };
            my $job_id =
              Koha::BackgroundJob::BatchDeleteItem->new->enqueue($params);
            $nextop = 'enqueued';
            $template->param( job_id => $job_id, );
                        my $itemdata = $item->unblessed;
                        my $return = $item->safe_delete;
                        if ( ref( $return ) ) {
                            $deleted_items++;
                            push @$upd_biblionumbers, $itemdata->{'biblionumber'};
                        }
                        else {
                            $not_deleted_items++;
                            push @not_deleted,
                              {
                                biblionumber => $itemdata->{'biblionumber'},
                                itemnumber   => $itemdata->{'itemnumber'},
                                barcode      => $itemdata->{'barcode'},
                                title        => $itemdata->{'title'},
                                reason       => $return,
                              };
                        }

                        # If there are no items left, delete the biblio
                        if ($del_records) {
                            my $itemscount = Koha::Biblios->find( $itemdata->{'biblionumber'} )->items->count;
                            if ( $itemscount == 0 ) {
                                my $error = DelBiblio( $itemdata->{'biblionumber'}, { skip_record_index => 1 } );
                                unless ($error) {
                                    $deleted_records++;
                                    push @$del_biblionumbers, $itemdata->{'biblionumber'};
                                    if ( $src eq 'CATALOGUING' ) {
                                        # We are coming catalogue/detail.pl, there were items from a single bib record
                                        $template->param( biblio_deleted => 1 );
                                    }
                                }
                            }
                        }
                    }
                    if (@not_deleted) {
                        Koha::Exceptions::Exception->throw(
                            'Some items have not been deleted, rolling back');
                    }
                }
            );
        }
        catch {
            warn $_;
            push @messages,
              {
                type  => 'error',
                code  => 'cannot_enqueue_job',
                error => $_,
              };
            $template->param( view => 'errors' );
        };
    }

    else {    # modification

        my @item_columns = Koha::Items->columns;

        my $new_item_data;
        my ( $columns_with_regex );
        my @subfields_to_blank = $input->multi_param('disable_input');
        my @more_subfields = $input->multi_param("items.more_subfields_xml");
        for my $item_column (@item_columns) {
            my @attributes       = ($item_column);
            my $cgi_param_prefix = 'items.';
            if ( $item_column eq 'more_subfields_xml' ) {
                @attributes       = ();
                $cgi_param_prefix = 'items.more_subfields_xml_';
                for my $subfield (@more_subfields) {
                    push @attributes, $subfield;
                    # use of tag 999 is arbitrary, and doesn't need to match the item tag
                    # used in the framework
                    $marc->append_fields(MARC::Field->new('999', ' ', ' ', @unlinked_item_subfields));
                    $marc->encoding("UTF-8");
                    # FIXME This is WRONG! We need to use the values that haven't been modified by the batch tool!
                    $new_item_data->{more_subfields_xml} = $marc->as_xml("USMARC");
                    next;
                }
            }
                # FIXME deal with more_subfields_xml and @subfields_to_blank
            } elsif ( grep { $c eq $_ } @subfields_to_blank ) {
                # Empty this column
                $new_item_data->{$c} = undef
            } else {

            for my $attr (@attributes) {
                    uniq $input->multi_param( "items." . $c );

                my $cgi_var_name = $cgi_param_prefix
                  . encode_utf8($attr)
                  ;  # We need to deal correctly with encoding on subfield codes

                if ( grep { $attr eq $_ } @subfields_to_blank ) {

                    # Empty this column
                    $new_item_data->{$attr} = undef;
                }
                elsif ( my $regex_search =
                    $input->param( $cgi_var_name . '_regex_search' ) )
                {
                    $columns_with_regex->{$attr} = {
                        search => $regex_search,
                        replace =>
                          $input->param( $cgi_var_name . '_regex_replace' ),
                        modifiers =>
                          $input->param( $cgi_var_name . '_regex_modifiers' )
                    };
                }
                else {
                    my @v =
                      grep { $_ ne "" } uniq $input->multi_param($cgi_var_name);

                    next unless @v;

                    $new_item_data->{$attr} = join '|', @v;
                }
            }
        }

        my $params = {
            record_ids                        => \@itemnumbers,
            regex_mod                         => $columns_with_regex,
            new_values                        => $new_item_data,
            exclude_from_local_holds_priority => (
                defined $exclude_from_local_holds_priority
                  && $exclude_from_local_holds_priority ne ""
              )
            ? $exclude_from_local_holds_priority
            : undef,

        };
        try {
            my $job_id =
              Koha::BackgroundJob::BatchUpdateItem->new->enqueue($params);
            $nextop = 'enqueued';
            $template->param( job_id => $job_id, );
                    foreach my $itemnumber (@itemnumbers) {
                        my $item = Koha::Items->find($itemnumber);
                        next
                          unless $item
                          ; # Should have been tested earlier, but just in case...
                        my $itemdata = $item->unblessed;

                        my $modified_holds_priority = 0;
                        if ( defined $exclude_from_local_holds_priority && $exclude_from_local_holds_priority ne "" ) {
                            if(!defined $item->exclude_from_local_holds_priority || $item->exclude_from_local_holds_priority != $exclude_from_local_holds_priority) {
                                $item->exclude_from_local_holds_priority($exclude_from_local_holds_priority)->store;
                                $modified_holds_priority = 1;
                            }
                        }

                        my $modified = 0;
                        for my $c ( @columns_with_regex ) {
                            my $regex_search = $input->param('items.'.$c.'_regex_search');
                            my $old_value = $item->$c;

                            my $value = apply_regex(
                                {
                                    search  => $regex_search,
                                    replace => $input->param(
                                        'items' . $c . '_regex_replace'
                                    ),
                                    modifiers => $input->param(
                                        'items' . $c . '_regex_modifiers'
                                    ),
                                    value => $old_value,
                                }
                            );
                            unless ( $old_value eq $value ) {
                                $modified++;
                                $item->$c($value);
                            }
                        }

                        $modified += scalar(keys %$new_item_data); # FIXME This is incorrect if old value == new value. Should we loop of the keys and compare the before/after values?
                        if ( $modified) {
                            my $itemlost_pre = $item->itemlost;
                            $item->set($new_item_data)->store({skip_record_index => 1});

                            push @$upd_biblionumbers, $itemdata->{'biblionumber'};

                            LostItem(
                                $item->itemnumber, 'batchmod', undef,
                                { skip_record_index => 1 }
                            ) if $item->itemlost
                                  and not $itemlost_pre;
                        }

                        $modified_items++ if $modified || $modified_holds_priority;
                        $modified_fields += $modified + $modified_holds_priority;
                    }
                }
            );
        }
        catch {
            push @messages,
              {
                type  => 'error',
                code  => 'cannot_enqueue_job',
                error => $_,
              };
            $template->param( view => 'errors' );
        };
    }

    $upd_biblionumbers = [ uniq @$upd_biblionumbers ]; # Only update each bib once

    # Don't send specialUpdate for records we are going to delete
    my %del_bib_hash = map{ $_ => undef } @$del_biblionumbers;
    @$upd_biblionumbers = grep( ! exists( $del_bib_hash{$_} ), @$upd_biblionumbers );

    my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
    $indexer->index_records( $upd_biblionumbers, 'specialUpdate', "biblioserver", undef ) if @$upd_biblionumbers;
    $indexer->index_records( $del_biblionumbers, 'recordDelete', "biblioserver", undef ) if @$del_biblionumbers;

    # Once the job is done
    # If we have a reasonable amount of items, we display them
    my $max_items = $del ? C4::Context->preference("MaxItemsToDisplayForBatchDel") : C4::Context->preference("MaxItemsToDisplayForBatchMod");
    if (scalar(@itemnumbers) <= $max_items ){
        if (scalar(@itemnumbers) <= 1000 ) {
            $items_display_hashref=BuildItemsData(@itemnumbers);
        } else {
            # Else, we only display the barcode
            my @simple_items_display = map {
                my $itemnumber = $_;
                my $item = Koha::Items->find($itemnumber);
                {
                    itemnumber   => $itemnumber,
                    barcode      => $item ? ( $item->barcode // q{} ) : q{},
                    biblionumber => $item ? $item->biblio->biblionumber : q{},
                };
            } @itemnumbers;
            $template->param("simple_items_display" => \@simple_items_display);
        }
    } else {
        $template->param( "too_many_items_display" => scalar(@itemnumbers) );
        $template->param( "job_completed" => 1 );
    }


    # Calling the template
    $template->param(
        modified_items => $modified_items,
        modified_fields => $modified_fields,
    );

}

$template->param(
    messages => \@messages,
);
#
#-------------------------------------------------------------------------------
# build screen with existing items. and "new" one

        }
    } else {
        if (defined $biblionumber && !@itemnumbers){
            my $biblio = Koha::Biblios->find($biblionumber);
            @itemnumbers = $biblio ? $biblio->items->get_column('itemnumber') : ();
                push @itemnumbers, $itm->{itemnumber};
            }
        }
        if ( my $list = $input->param('barcodelist') ) {
            my @barcodelist = grep /\S/, ( split /[$split_chars]/, $list );

        : C4::Context->preference("MaxItemsToDisplayForBatchMod");
    $template->param("too_many_items_process" => scalar(@itemnumbers)) if !$del && scalar(@itemnumbers) > C4::Context->preference("MaxItemsToProcessForBatchMod");
    if (scalar(@itemnumbers) <= ( $max_display_items // 1000 ) ) {
        $display_items = 1;
    } else {
        $template->param("too_many_items_display" => scalar(@itemnumbers));
        # Even if we do not display the items, we need the itemnumbers

    }

    # now, build the item form for entering a new item
    my @loop_data =();
    my $branch_limit = C4::Context->userenv ? C4::Context->userenv->{"branch"} : "";

    my $pref_itemcallnumber = C4::Context->preference('itemcallnumber');

    # Getting list of subfields to keep when restricted batchmod edit is enabled
    my @subfields_to_allow = $restrictededition ? split ' ', C4::Context->preference('SubfieldsToAllowForRestrictedBatchmod') : ();

                ? ( subfields_to_allow => \@subfields_to_allow )
                : ()
            ),
            ignore_not_allowed_subfields => 1,
            kohafields_to_ignore         => ['items.barcode'],
            prefill_with_default_values => $use_default_values,
            default_branches_empty      => 1,
        }

    $nextop="action"
} # -- End action="show"

if ( $display_items ) {
    my $items_table =
      Koha::UI::Table::Builder::Items->new( { itemnumbers => \@itemnumbers } )
      ->build_table;
$template->param( $op => 1 ) if $op;

if ($op eq "action") {

    #my @not_deleted_loop = map{{itemnumber=>$_}}@not_deleted;

    $template->param(
        items        => $items_table->{items},
        item_header_loop => $items_table->{headers},
	delete_records => $del_records,
	deleted_records => $deleted_records,
	not_deleted_loop => \@not_deleted 
    );
}

$template->param(
    op  => $nextop,
    del => $del,
    ( $op ? ( $op => 1 ) : () ),
    src          => $src,
    biblionumber => $biblionumber,
);


# ---------------- Functions

sub BuildItemsData{
	my @itemnumbers=@_;
		# now, build existiing item list
		my %witness; #---- stores the list of subfields used at least once, with the "meaning" of the code
		my @big_array;
		#---- finds where items.itemnumber is stored
    my (  $itemtagfield,   $itemtagsubfield) = &GetMarcFromKohaField( "items.itemnumber" );
    my ($branchtagfield, $branchtagsubfield) = &GetMarcFromKohaField( "items.homebranch" );
		foreach my $itemnumber (@itemnumbers){
            my $itemdata = Koha::Items->find($itemnumber);
            next unless $itemdata; # Should have been tested earlier, but just in case...
            $itemdata = $itemdata->unblessed;
			my $itemmarc=Item2Marc($itemdata);
			my %this_row;
			foreach my $field (grep {$_->tag() eq $itemtagfield} $itemmarc->fields()) {
				# loop through each subfield
				my $itembranchcode=$field->subfield($branchtagsubfield);
                if ($itembranchcode && C4::Context->preference("IndependentBranches")) {
						#verifying rights
						my $userenv = C4::Context->userenv();
                        unless (C4::Context->IsSuperLibrarian() or (($userenv->{'branch'} eq $itembranchcode))){
								$this_row{'nomod'}=1;
						}
				}
				my $tag=$field->tag();
				foreach my $subfield ($field->subfields) {
					my ($subfcode,$subfvalue)=@$subfield;
					next if ($tagslib->{$tag}->{$subfcode}->{tab} ne 10 
							&& $tag        ne $itemtagfield 
							&& $subfcode   ne $itemtagsubfield);

					$witness{$subfcode} = $tagslib->{$tag}->{$subfcode}->{lib} if ($tagslib->{$tag}->{$subfcode}->{tab}  eq 10);
					if ($tagslib->{$tag}->{$subfcode}->{tab}  eq 10) {
						$this_row{$subfcode}=GetAuthorisedValueDesc( $tag,
									$subfcode, $subfvalue, '', $tagslib) 
									|| $subfvalue;
					}

					$this_row{itemnumber} = $subfvalue if ($tag eq $itemtagfield && $subfcode eq $itemtagsubfield);
				}
			}

            # grab title, author, and ISBN to identify bib that the item
            # belongs to in the display
            my $biblio = Koha::Biblios->find( $itemdata->{biblionumber} );
            $this_row{title}        = $biblio->title;
            $this_row{author}       = $biblio->author;
            $this_row{isbn}         = $biblio->biblioitem->isbn;
            $this_row{biblionumber} = $biblio->biblionumber;
            $this_row{holds}        = $biblio->holds->count;
            $this_row{item_holds}   = Koha::Holds->search( { itemnumber => $itemnumber } )->count;
            $this_row{item}         = Koha::Items->find($itemnumber);

			if (%this_row) {
				push(@big_array, \%this_row);
			}
		}
		@big_array = sort {$a->{0} cmp $b->{0}} @big_array;

		# now, construct template !
		# First, the existing items for display
		my @item_value_loop;
		my @witnesscodessorted=sort keys %witness;
		for my $row ( @big_array ) {
			my %row_data;
			my @item_fields = map +{ field => $_ || '' }, @$row{ @witnesscodessorted };
			$row_data{item_value} = [ @item_fields ];
			$row_data{itemnumber} = $row->{itemnumber};
			#reporting this_row values
			$row_data{'nomod'} = $row->{'nomod'};
      $row_data{bibinfo} = $row->{bibinfo};
      $row_data{author} = $row->{author};
      $row_data{title} = $row->{title};
      $row_data{isbn} = $row->{isbn};
      $row_data{biblionumber} = $row->{biblionumber};
      $row_data{holds}        = $row->{holds};
      $row_data{item_holds}   = $row->{item_holds};
      $row_data{item}         = $row->{item};
      $row_data{safe_to_delete} = $row->{item}->safe_to_delete;
      my $is_on_loan = C4::Circulation::IsItemIssued( $row->{itemnumber} );
      $row_data{onloan} = $is_on_loan ? 1 : 0;
			push(@item_value_loop,\%row_data);
		}
		my @header_loop=map { { header_value=> $witness{$_}} } @witnesscodessorted;

    my @cannot_be_deleted = map {
        $_->{safe_to_delete} == 1 ? () : $_->{item}->barcode
    } @item_value_loop;
    return {
        item_loop        => \@item_value_loop,
        cannot_be_deleted => \@cannot_be_deleted,
        item_header_loop => \@header_loop
    };
}

#BE WARN : it is not the general case 
# This function can be OK in the item marc record special case
# Where subfield is not repeated
# And where we are sure that field should correspond
# And $tag>10
sub UpdateMarcWith {
  my ($marcfrom,$marcto)=@_;
    my (  $itemtag,   $itemtagsubfield) = &GetMarcFromKohaField( "items.itemnumber" );
    my $fieldfrom=$marcfrom->field($itemtag);
    my @fields_to=$marcto->field($itemtag);
    my $modified = 0;

    return $modified unless $fieldfrom;

    foreach my $subfield ( $fieldfrom->subfields() ) {
        foreach my $field_to_update ( @fields_to ) {
            if ( $subfield->[1] ) {
                unless ( $field_to_update->subfield($subfield->[0]) eq $subfield->[1] ) {
                    $modified++;
                    $field_to_update->update( $subfield->[0] => $subfield->[1] );
                }
            }
            else {
                $modified++;
                $field_to_update->delete_subfield( code => $subfield->[0] );
            }
        }
    }
    return $modified;
}

sub apply_regex {
    my ($params) = @_;
    my $search   = $params->{search};
    my $replace  = $params->{replace};
    my $modifiers = $params->{modifiers} || [];
    my $value = $params->{value};

    my @available_modifiers = qw( i g );
    my $retained_modifiers  = q||;
    for my $modifier ( split //, @$modifiers ) {
        $retained_modifiers .= $modifier
          if grep { /$modifier/ } @available_modifiers;
    }
    if ( $retained_modifiers =~ m/^(ig|gi)$/ ) {
        $value =~ s/$search/$replace/ig;
    }
    elsif ( $retained_modifiers eq 'i' ) {
        $value =~ s/$search/$replace/i;
    }
    elsif ( $retained_modifiers eq 'g' ) {
        $value =~ s/$search/$replace/g;
    }
    else {
        $value =~ s/$search/$replace/;
    }

output_html_with_http_headers $input, $cookie, $template->output;
}
- 

Return to bug 28445

Lines 38-43 use Koha::SearchEngine::Indexer; Link Here

(-)a/Koha/Item.pm (-24 / +60 lines)
38	use Koha::Exceptions::Item::Transfer;	38	use Koha::Exceptions::Item::Transfer;
39	use Koha::Item::Transfer::Limits;	39	use Koha::Item::Transfer::Limits;
40	use Koha::Item::Transfers;	40	use Koha::Item::Transfers;
		41	use Koha::Item::Attributes;
41	use Koha::ItemTypes;	42	use Koha::ItemTypes;
42	use Koha::Patrons;	43	use Koha::Patrons;
43	use Koha::Plugins;	44	use Koha::Plugins;
Lines 850-857 sub has_pending_hold { Link Here
850		851
851	=head3 as_marc_field	852	=head3 as_marc_field
852		853
853	my $mss = C4::Biblio::GetMarcSubfieldStructure( '', { unsafe => 1 } );	854	my $field = $item->as_marc_field;
854	my $field = $item->as_marc_field({ [ mss => $mss ] });
855		855
856	This method returns a MARC::Field object representing the Koha::Item object	856	This method returns a MARC::Field object representing the Koha::Item object
857	with the current mappings configuration.	857	with the current mappings configuration.
Lines 859-895 with the current mappings configuration. Link Here
859	=cut	859	=cut
860		860
861	sub as_marc_field {	861	sub as_marc_field {
862	my ( $self, $params ) = @_;	862	my ( $self ) = @_;
863		863
864	my $mss = $params->{mss} // C4::Biblio::GetMarcSubfieldStructure( '', { unsafe => 1 } );	864	my ( $itemtag, $itemtagsubfield) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );
865	my $item_tag = $mss->{'items.itemnumber'}[0]->{tagfield};
866		865
867	my @subfields;	866	my $tagslib = C4::Biblio::GetMarcStructure( 1, $self->biblio->frameworkcode, { unsafe => 1 });
868		867
869	my @columns = $self->_result->result_source->columns;	868	my @subfields;
870		869
871	foreach my $item_field ( @columns ) {	870	my $item_field = $tagslib->{$itemtag};
872	my $mapping = $mss->{ "items.$item_field"}[0];	871
873	my $tagfield = $mapping->{tagfield};	872	my $more_subfields = $self->additional_attributes->to_hashref;
874	my $tagsubfield = $mapping->{tagsubfield};	873	foreach my $subfield (
875	next if !$tagfield; # TODO: Should we raise an exception instead?	874	sort {
876	# Feels like safe fallback is better	875	$a->{display_order} <=> $b->{display_order}
		876	\|\| $a->{subfield} cmp $b->{subfield}
		877	} grep { ref($_) && %$_ } values %$item_field
		878	){
		879
		880	my $kohafield = $subfield->{kohafield};
		881	my $tagsubfield = $subfield->{tagsubfield};
		882	my $value;
		883	if ( defined $kohafield ) {
		884	next if $kohafield !~ m{^items\.}; # That would be weird!
		885	( my $attribute = $kohafield ) =~ s\|^items\.\|\|;
		886	$value = $self->$attribute # This call may fail if a kohafield is not a DB column but we don't want to add extra work for that there
		887	if defined $self->$attribute and $self->$attribute ne '';
		888	} else {
		889	$value = $more_subfields->{$tagsubfield}
		890	}
877		891
878	push @subfields, $tagsubfield => $self->$item_field	892	next unless defined $value
879	if defined $self->$item_field and $item_field ne '';	893	and $value ne q{};
880	}
881		894
882	my $unlinked_item_subfields = C4::Items::_parse_unlinked_item_subfields_from_xml($self->more_subfields_xml);	895	if ( $subfield->{repeatable} ) {
883	push( @subfields, @{$unlinked_item_subfields} )	896	my @values = split '\\|', $value;
884	if defined $unlinked_item_subfields and $#$unlinked_item_subfields > -1;	897	push @subfields, ( $tagsubfield => $_ ) for @values;
		898	}
		899	else {
		900	push @subfields, ( $tagsubfield => $value );
		901	}
885		902
886	my $field;	903	}
887		904
888	$field = MARC::Field->new(	905	return unless @subfields;
889	"$item_tag", ' ', ' ', @subfields
890	) if @subfields;
891		906
892	return $field;	907	return MARC::Field->new(
		908	"$itemtag", ' ', ' ', @subfields
		909	);
893	}	910	}
894		911
895	=head3 renewal_branchcode	912	=head3 renewal_branchcode
Lines 1019-1024 sub columns_to_str { Link Here
1019	return $values;	1036	return $values;
1020	}	1037	}
1021		1038
		1039	=head3 additional_attributes
		1040
		1041	my $attributes = $item->additional_attributes;
		1042	$attributes->{k} = 'new k';
		1043	$item->update({ more_subfields => $attributes->to_marcxml });
		1044
		1045	Returns a Koha::Item::Attributes object that represents the non-mapped
		1046	attributes for this item.
		1047
		1048	=cut
		1049
		1050	sub additional_attributes {
		1051	my ($self) = @_;
		1052
		1053	return Koha::Item::Attributes->new_from_marcxml(
		1054	$self->more_subfields_xml,
		1055	);
		1056	}
		1057
1022	=head3 _set_found_trigger	1058	=head3 _set_found_trigger
1023		1059
1024	$self->_set_found_trigger	1060	$self->_set_found_trigger

Line 0 Link Here

(-)a/Koha/BackgroundJob/BatchDeleteItem.pm (+227 lines)
		1	package Koha::BackgroundJob::BatchDeleteItem;
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	=head1 NAME
		19
		20	Koha::BackgroundJob::BatchDeleteItem - Background job derived class to process item deletion in batch
		21
		22	=cut
		23
		24	use Modern::Perl;
		25	use JSON qw( encode_json decode_json );
		26	use List::MoreUtils qw( uniq );
		27	use Try::Tiny;
		28
		29	use Koha::BackgroundJobs;
		30	use Koha::DateUtils qw( dt_from_string );
		31
		32	use base 'Koha::BackgroundJob';
		33
		34	=head1 API
		35
		36	=head2 Class methods
		37
		38	=head3 job_type
		39
		40	Return the job type 'batch_item_record_deletion'.
		41
		42	=cut
		43
		44	sub job_type {
		45	return 'batch_item_record_deletion';
		46	}
		47
		48	=head3 process
		49
		50	Koha::BackgroundJobs->find($id)->process(
		51	{
		52	record_ids => \@itemnumbers,
		53	deleted_biblios => 0\|1,
		54	}
		55	);
		56
		57	Will delete all the items that have been passed for deletion.
		58
		59	When deleted_biblios is passed, if we deleted the last item of a biblio,
		60	the bibliographic record will be deleted as well.
		61
		62	The search engine's index will be updated according to the changes made
		63	to the deleted bibliographic recods.
		64
65	The generated report will be:
66	{
67	deleted_itemnumbers => \@list_of_itemnumbers,
68	not_deleted_itemnumbers => \@list_of_itemnumbers,
69	deleted_biblionumbers=> \@list_of_biblionumbers,
70	}
71
72	=cut
73
74	sub process {
75	my ( $self, $args ) = @_;
76
77	my $job_type = $args->{job_type};
78
79	my $job = Koha::BackgroundJobs->find( $args->{job_id} );
80
81	if ( !exists $args->{job_id} \|\| !$job \|\| $job->status eq 'cancelled' ) {
82	return;
83	}
84
85	# FIXME If the job has already been started, but started again (worker has been restart for instance)
86	# Then we will start from scratch and so double delete the same records
87
88	my $job_progress = 0;
89	$job->started_on(dt_from_string)->progress($job_progress)
90	->status('started')->store;
91
92	my @record_ids = @{ $args->{record_ids} };
93	my $delete_biblios = $args->{delete_biblios};
94
95	my $report = {
96	total_records => scalar @record_ids,
97	total_success => 0,
98	};
99	my @messages;
100	my $schema = Koha::Database->new->schema;
101	my ( @deleted_itemnumbers, @not_deleted_itemnumbers,
102	@deleted_biblionumbers );
103
104	try {
105	my $schema = Koha::Database->new->schema;
106	$schema->txn_do(
107	sub {
108	my (@biblionumbers);
109	for my $record_id ( sort { $a <=> $b } @record_ids ) {
110
111	last if $job->get_from_storage->status eq 'cancelled';
112
113	my $item = Koha::Items->find($record_id) \|\| next;
114
115	my $return = $item->safe_delete;
116	unless ( ref($return) ) {
117
118	# FIXME Do we need to rollback the whole transaction if a deletion failed?
119	push @not_deleted_itemnumbers, $item->itemnumber;
120	push @messages,
121	{
122	type => 'error',
123	code => 'item_not_deleted',
124	itemnumber => $item->itemnumber,
125	biblionumber => $item->biblionumber,
126	barcode => $item->barcode,
127	title => $item->biblio->title,
128	reason => $return,
129	};
130
131	next;
132	}
133
134	push @deleted_itemnumbers, $item->itemnumber;
135	push @biblionumbers, $item->biblionumber;
136
137	$report->{total_success}++;
138	$job->progress( ++$job_progress )->store;
139	}
140
141	# If there are no items left, delete the biblio
142	if ( $delete_biblios && @biblionumbers ) {
143	for my $biblionumber ( uniq @biblionumbers ) {
144	my $items_count =
145	Koha::Biblios->find($biblionumber)->items->count;
146	if ( $items_count == 0 ) {
147	my $error = C4::Biblio::DelBiblio( $biblionumber,
148	{ skip_record_index => 1 } );
149	unless ($error) {
150	push @deleted_biblionumbers, $biblionumber;
151	}
152	}
153	}
154
155	if (@deleted_biblionumbers) {
156	my $indexer = Koha::SearchEngine::Indexer->new(
157	{ index => $Koha::SearchEngine::BIBLIOS_INDEX } );
158
159	$indexer->index_records( \@deleted_biblionumbers,
160	'recordDelete', "biblioserver", undef );
161	}
162	}
163	}
164	);
165	}
166	catch {
167
168	warn $_;
169
170	push @messages,
171	{
172	type => 'error',
173	code => 'unknown',
174	error => $_,
175	};
176
177	die "Something terrible has happened!"
178	if ( $_ =~ /Rollback failed/ ); # Rollback failed
179	};
180
181	$report->{deleted_itemnumbers} = \@deleted_itemnumbers;
182	$report->{not_deleted_itemnumbers} = \@not_deleted_itemnumbers;
183	$report->{deleted_biblionumbers} = \@deleted_biblionumbers;
184
185	my $job_data = decode_json $job->data;
186	$job_data->{messages} = \@messages;
187	$job_data->{report} = $report;
188
189	$job->ended_on(dt_from_string)->data( encode_json $job_data);
190	$job->status('finished') if $job->status ne 'cancelled';
191	$job->store;
192	}
193
194	=head3 enqueue
195
196	Koha::BackgroundJob::BatchDeleteItem->new->enqueue(
197	{
198	record_ids => \@itemnumbers,
199	deleted_biblios => 0\|1,
200	}
201	);
202
203	Enqueue the job.
204
205	=cut
206
207	sub enqueue {
208	my ( $self, $args ) = @_;
209
210	# TODO Raise exception instead
211	return unless exists $args->{record_ids};
212
213	my @record_ids = @{ $args->{record_ids} };
214	my $delete_biblios = @{ $args->{delete_biblios} \|\| [] };
215
216	$self->SUPER::enqueue(
217	{
218	job_size => scalar @record_ids,
219	job_args => {
220	record_ids => \@record_ids,
221	delete_biblios => $delete_biblios,
222	}
223	}
224	);
225	}
226
227	1;

Line 0 Link Here

(-)a/Koha/BackgroundJob/BatchUpdateItem.pm (+193 lines)
		1	package Koha::BackgroundJob::BatchUpdateItem;
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19	use JSON qw( encode_json decode_json );
		20	use List::MoreUtils qw( uniq );
		21	use Try::Tiny;
		22
		23	use MARC::Record;
		24	use MARC::Field;
		25
		26	use C4::Biblio;
		27	use C4::Items;
		28
		29	use Koha::BackgroundJobs;
		30	use Koha::DateUtils qw( dt_from_string );
		31	use Koha::SearchEngine::Indexer;
		32	use Koha::Items;
		33	use Koha::UI::Table::Builder::Items;
		34
		35	use base 'Koha::BackgroundJob';
		36
		37	=head1 NAME
		38
		39	Koha::BackgroundJob::BatchUpdateItem - Background job derived class to process item modification in batch
		40
		41	=head1 API
		42
		43	=head2 Class methods
		44
		45	=head3 job_type
		46
		47	Define the job type of this job: batch_item_record_modification
		48
		49	=cut
		50
		51	sub job_type {
		52	return 'batch_item_record_modification';
		53	}
		54
		55	=head3 process
		56
		57	Koha::BackgroundJobs->find($id)->process(
		58	{
		59	record_ids => \@itemnumbers,
		60	new_values => {
		61	itemnotes => $new_item_notes,
		62	k => $k,
		63	},
		64	regex_mod => {
65	itemnotes_nonpublic => {
66	search => 'foo',
67	replace => 'bar',
68	modifiers => 'gi',
69	},
70	},
71	exclude_from_local_holds_priority => 1\|0
72	}
73	);
74
75	Process the modification.
76
77	new_values allows to set a new value for given fields.
78	The key can be one of the item's column name, or one subfieldcode of a MARC subfields not linked with a Koha field.
79
80	regex_mod allows to modify existing subfield's values using a regular expression.
81
82	=cut
83
84	sub process {
85	my ( $self, $args ) = @_;
86
87	my $job = Koha::BackgroundJobs->find( $args->{job_id} );
88
89	if ( !exists $args->{job_id} \|\| !$job \|\| $job->status eq 'cancelled' ) {
90	return;
91	}
92
93	# FIXME If the job has already been started, but started again (worker has been restart for instance)
94	# Then we will start from scratch and so double process the same records
95
96	my $job_progress = 0;
97	$job->started_on(dt_from_string)->progress($job_progress)
98	->status('started')->store;
99
100	my @record_ids = @{ $args->{record_ids} };
101	my $regex_mod = $args->{regex_mod};
102	my $new_values = $args->{new_values};
103	my $exclude_from_local_holds_priority =
104	$args->{exclude_from_local_holds_priority};
105
106	my $report = {
107	total_records => scalar @record_ids,
108	modified_itemitemnumbers => [],
109	modified_fields => 0,
110	};
111
112	try {
113	my $schema = Koha::Database->new->schema;
114	$schema->txn_do(
115	sub {
116	my ($results) =
117	Koha::Items->search( { itemnumber => \@record_ids } )
118	->batch_update(
119	{
120	regex_mod => $regex_mod,
121	new_values => $new_values,
122	exclude_from_local_holds_priority =>
123	$exclude_from_local_holds_priority,
124	callback => sub {
125	my ($progress) = @_;
126	$job->progress($progress)->store;
127	},
128	}
129	);
130	$report->{modified_itemnumbers} = $results->{modified_itemnumbers};
131	$report->{modified_fields} = $results->{modified_fields};
132	}
133	);
134	}
135	catch {
136	warn $_;
137	die "Something terrible has happened!"
138	if ( $_ =~ /Rollback failed/ ); # Rollback failed
139	};
140
141	my $job_data = decode_json $job->data;
142	$job_data->{report} = $report;
143
144	$job->ended_on(dt_from_string)->data( encode_json $job_data);
145	$job->status('finished') if $job->status ne 'cancelled';
146	$job->store;
147	}
148
149	=head3 enqueue
150
151	Enqueue the new job
152
153	=cut
154
155	sub enqueue {
156	my ( $self, $args ) = @_;
157
158	# TODO Raise exception instead
159	return unless exists $args->{record_ids};
160
161	my @record_ids = @{ $args->{record_ids} };
162
163	$self->SUPER::enqueue(
164	{
165	job_size => scalar @record_ids,
166	job_args => {%$args},
167	}
168	);
169	}
170
171	=head3 additional_report
172
173	Sent the infos to generate the table containing the details of the modified items.
174
175	=cut
176
177	sub additional_report {
178	my ( $self, $args ) = @_;
179
180	my $job = Koha::BackgroundJobs->find( $args->{job_id} );
181
182	my $itemnumbers = $job->report->{modified_itemnumbers};
183	my $items_table =
184	Koha::UI::Table::Builder::Items->new( { itemnumbers => $itemnumbers } )
185	->build_table;
186
187	return {
188	items => $items_table->{items},
189	item_header_loop => $items_table->{headers},
190	};
191	}
192
193	1;

Line 0 Link Here

(-)a/Koha/Item/Attributes.pm (+149 lines)
		1	package Koha::Item::Attributes;
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19	use MARC::Record;
		20	use MARC::Field;
		21	use List::MoreUtils qw( uniq );
		22
		23	use C4::Biblio;
		24	use C4::Charset qw( StripNonXmlChars );
		25
		26	=head1 NAME
		27
		28	Koha::Item::Attributes - Class to represent the additional attributes of items.
		29
		30	Additional attributes are 'more subfields xml'
		31
		32	=head1 API
		33
		34	=head2 Class methods
		35
		36	=cut
		37
		38	=head3 new_from_marcxml
		39
		40	my $attributes = Koha::Item::Attributes->new_from_marcxml( $item->more_subfield_xml );
		41
		42	Constructor that takes a MARCXML.
		43
		44	=cut
		45
		46	# FIXME maybe this needs to care about repeatable but don't from batchMod - To implement later?
		47	sub new_from_marcxml {
		48	my ( $class, $more_subfields_xml ) = @_;
		49
		50	my $self = {};
		51	if ($more_subfields_xml) {
		52	# FIXME MARC::Record->new_from_xml (vs MARC::Record::new_from_xml) does not return the correctly encoded subfield code (??)
		53	my $marc_more =
		54	MARC::Record::new_from_xml(
		55	C4::Charset::StripNonXmlChars($more_subfields_xml), 'UTF-8' );
		56
		57	# use of tag 999 is arbitrary, and doesn't need to match the item tag
		58	# used in the framework
		59	my $field = $marc_more->field('999');
		60	my $more_subfields = [ uniq map { $_->[0] } $field->subfields ];
		61	for my $more_subfield (@$more_subfields) {
		62	my @s = $field->subfield($more_subfield);
		63	$self->{$more_subfield} = join '\|', @s;
		64	}
65	}
66	return bless $self, $class;
67	}
68
69	=head3 new
70
71	Constructor
72
73	=cut
74
75	# FIXME maybe this needs to care about repeatable but don't from batchMod - To implement later?
76	sub new {
77	my ( $class, $attributes ) = @_;
78
79	my $self = $attributes;
80	return bless $self, $class;
81	}
82
83	=head3 to_marcxml
84
85	$attributes->to_marcxml;
86
87	$item->more_subfields_xml( $attributes->to_marcxml );
88
89	Return the MARCXML representation of the attributes.
90
91	=cut
92
93	sub to_marcxml {
94	my ( $self, $frameworkcode ) = @_;
95
96	return unless keys %$self;
97
98	my $tagslib =
99	C4::Biblio::GetMarcStructure( 1, $frameworkcode, { unsafe => 1 } );
100
101	my ( $itemtag, $itemtagsubfield ) =
102	C4::Biblio::GetMarcFromKohaField("items.itemnumber");
103	my @subfields;
104	for my $tagsubfield (
105	sort {
106	$tagslib->{$itemtag}->{$a}->{display_order} <=> $tagslib->{$itemtag}->{$b}->{display_order}
107	\|\| $tagslib->{$itemtag}->{$a}->{subfield} cmp $tagslib->{$itemtag}->{$b}->{subfield}
108	} keys %$self
109	)
110	{
111	next
112	if not defined $self->{$tagsubfield}
113	or $self->{$tagsubfield} eq "";
114
115	if ( $tagslib->{$itemtag}->{$tagsubfield}->{repeatable} ) {
116	my @values = split '\\|', $self->{$tagsubfield};
117	push @subfields, ( $tagsubfield => $_ ) for @values;
118	}
119	else {
120	push @subfields, ( $tagsubfield => $self->{$tagsubfield} );
121	}
122	}
123
124	return unless @subfields;
125
126	my $marc_more = MARC::Record->new();
127
128	# use of tag 999 is arbitrary, and doesn't need to match the item tag
129	# used in the framework
130	$marc_more->append_fields(
131	MARC::Field->new( '999', ' ', ' ', @subfields ) );
132	$marc_more->encoding("UTF-8");
133	return $marc_more->as_xml("USMARC");
134	}
135
136	=head3 to_hashref
137
138	$attributes->to_hashref;
139
140	Returns the hashref representation of the attributes.
141
142	=cut
143
144	sub to_hashref {
145	my ($self) = @_;
146	return { map { $_ => $self->{$_} } keys %$self };
147	}
148
149	1;

Lines 82-87 sub generate_subfield_form { Link Here

(-)a/Koha/UI/Form/Builder/Item.pm (-23 / +29 lines)
82	my $prefill_with_default_values = $params->{prefill_with_default_values};	82	my $prefill_with_default_values = $params->{prefill_with_default_values};
83	my $branch_limit = $params->{branch_limit};	83	my $branch_limit = $params->{branch_limit};
84	my $default_branches_empty = $params->{default_branches_empty};	84	my $default_branches_empty = $params->{default_branches_empty};
		85	my $readonly = $params->{readonly};
85		86
86	my $item = $self->{item};	87	my $item = $self->{item};
87	my $subfield = $tagslib->{$tag}{$subfieldtag};	88	my $subfield = $tagslib->{$tag}{$subfieldtag};
Lines 380-407 sub generate_subfield_form { Link Here
380	};	381	};
381	}	382	}
382		383
383	# Getting list of subfields to keep when restricted editing is enabled	384	# If we're on restricted editing, and our field is not in the list of subfields to allow,
384	# FIXME Improve the following block, no need to do it for every subfields	385	# then it is read-only
385	my $subfieldsToAllowForRestrictedEditing =	386	$subfield_data{marc_value}->{readonly} = $readonly;
386	C4::Context->preference('SubfieldsToAllowForRestrictedEditing');
387	my $allowAllSubfields = (
388	not defined $subfieldsToAllowForRestrictedEditing
389	or $subfieldsToAllowForRestrictedEditing eq q\|\|
390	) ? 1 : 0;
391	my @subfieldsToAllow = split( / /, $subfieldsToAllowForRestrictedEditing );
392
393	# If we're on restricted editing, and our field is not in the list of subfields to allow,
394	# then it is read-only
395	$subfield_data{marc_value}->{readonly} =
396	( not $allowAllSubfields
397	and $restricted_edition
398	and !grep { $tag . '$' . $subfieldtag eq $_ } @subfieldsToAllow )
399	? 1
400	: 0;
401		387
402	return \%subfield_data;	388	return \%subfield_data;
403	}	389	}
404		390
		391	=head3 edit_form
		392
405	my $subfields =	393	my $subfields =
406	Koha::UI::Form::Builder::Item->new(	394	Koha::UI::Form::Builder::Item->new(
407	{ biblionumber => $biblionumber, item => $current_item } )->edit_form(	395	{ biblionumber => $biblionumber, item => $current_item } )->edit_form(
Lines 441-449 List of subfields to prefill (value of syspref SubfieldsToUseWhenPrefill) Link Here
441		429
442	=item subfields_to_allow	430	=item subfields_to_allow
443		431
444	List of subfields to allow (value of syspref SubfieldsToAllowForRestrictedBatchmod)	432	List of subfields to allow (value of syspref SubfieldsToAllowForRestrictedBatchmod or SubfieldsToAllowForRestrictedEditing)
		433
		434	=item ignore_not_allowed_subfields
		435
		436	If set, the subfields in subfields_to_allow will be ignored (ie. they will not be part of the subfield list.
		437	If not set, the subfields in subfields_to_allow will be marked as readonly.
445		438
446	=item subfields_to_ignore	439	=item kohafields_to_ignore
447		440
448	List of subfields to ignore/skip	441	List of subfields to ignore/skip
449		442
Lines 470-476 sub edit_form { Link Here
470	my $restricted_edition = $params->{restricted_editition};	463	my $restricted_edition = $params->{restricted_editition};
471	my $subfields_to_prefill = $params->{subfields_to_prefill} \|\| [];	464	my $subfields_to_prefill = $params->{subfields_to_prefill} \|\| [];
472	my $subfields_to_allow = $params->{subfields_to_allow} \|\| [];	465	my $subfields_to_allow = $params->{subfields_to_allow} \|\| [];
473	my $subfields_to_ignore= $params->{subfields_to_ignore} \|\| [];	466	my $ignore_not_allowed_subfields = $params->{ignore_not_allowed_subfields};
		467	my $kohafields_to_ignore = $params->{kohafields_to_ignore} \|\| [];
474	my $prefill_with_default_values = $params->{prefill_with_default_values};	468	my $prefill_with_default_values = $params->{prefill_with_default_values};
475	my $branch_limit = $params->{branch_limit};	469	my $branch_limit = $params->{branch_limit};
476	my $default_branches_empty = $params->{default_branches_empty};	470	my $default_branches_empty = $params->{default_branches_empty};
Lines 495-504 sub edit_form { Link Here
495		489
496	next if IsMarcStructureInternal($subfield);	490	next if IsMarcStructureInternal($subfield);
497	next if $subfield->{tab} ne "10";	491	next if $subfield->{tab} ne "10";
498	next if @$subfields_to_allow && !grep { $subfield->{kohafield} eq $_ } @$subfields_to_allow;
499	next	492	next
500	if grep { $subfield->{kohafield} && $subfield->{kohafield} eq $_ }	493	if grep { $subfield->{kohafield} && $subfield->{kohafield} eq $_ }
501	@$subfields_to_ignore;	494	@$kohafields_to_ignore;
		495
		496	my $readonly;
		497	if (
		498	@$subfields_to_allow && !grep {
		499	sprintf( "%s\$%s", $subfield->{tagfield}, $subfield->{tagsubfield} ) eq $_
		500	} @$subfields_to_allow
		501	)
		502	{
		503
		504	next if $ignore_not_allowed_subfields;
		505	$readonly = 1 if $restricted_edition;
		506	}
502		507
503	my @values = ();	508	my @values = ();
504		509
Lines 546-551 sub edit_form { Link Here
546	prefill_with_default_values => $prefill_with_default_values,	551	prefill_with_default_values => $prefill_with_default_values,
547	branch_limit => $branch_limit,	552	branch_limit => $branch_limit,
548	default_branches_empty => $default_branches_empty,	553	default_branches_empty => $default_branches_empty,
		554	readonly => $readonly
549	}	555	}
550	);	556	);
551	push @subfields, $subfield_data;	557	push @subfields, $subfield_data;

Line 0 Link Here

(-)a/Koha/UI/Table/Builder/Items.pm (+147 lines)
		1	package Koha::UI::Table::Builder::Items;
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19	use List::MoreUtils qw( uniq );
		20	use C4::Biblio qw( GetMarcStructure GetMarcFromKohaField IsMarcStructureInternal );
		21	use Koha::Items;
		22
		23	=head1 NAME
		24
		25	Koha::UI::Table::Builder::Items
		26
		27	Helper to build a table with a list of items with all their information.
		28
		29	Items' attributes that are mapped and not mapped will be listed in the table.
		30
		31	Only attributes that have been defined only once will be displayed (empty string is considered as not defined).
		32
		33	=head1 API
		34
		35	=head2 Class methods
		36
		37	=cut
		38
		39	=head3 new
		40
		41	my $table = Koha::UI::Table::Builder::Items->new( { itemnumbers => \@itemnumbers } );
		42
		43	Constructor.
		44
		45	=cut
		46
		47	sub new {
		48	my ( $class, $params ) = @_;
		49
		50	my $self;
		51	$self->{itemnumbers} = $params->{itemnumbers} \|\| [];
		52
		53	bless $self, $class;
		54	return $self;
		55	}
		56
		57	=head3 build_table
		58
		59	my $items_table = Koha::UI::Table::Builder::Items->new( { itemnumbers => \@itemnumbers } )
		60	->build_table;
		61
		62	my $items = $items_table->{items};
		63	my $headers = $items_table->{headers};
		64
65	Build the headers and rows for the table.
66
67	Use it with:
68	[% PROCESS items_table_batchmod headers => headers, items => items %]
69
70	=cut
71
72	sub build_table {
73	my ( $self, $params ) = @_;
74
75	my $items = Koha::Items->search( { itemnumber => $self->{itemnumbers} } );
76
77	my @items;
78	while ( my $item = $items->next ) {
79	my $item_info = $item->columns_to_str;
80	$item_info = {
81	%$item_info,
82	biblio => $item->biblio,
83	safe_to_delete => $item->safe_to_delete,
84	holds => $item->biblio->holds->count,
85	item_holds => $item->holds->count,
86	is_checked_out => $item->checkout \|\| 0,
87	};
88	push @items, $item_info;
89	}
90
91	$self->{headers} = $self->_build_headers( \@items );
92	$self->{items} = \@items;
93	return $self;
94	}
95
96	=head2 Internal methods
97
98	=cut
99
100	=head3 _build_headers
101
102	Build the headers given the items' info.
103
104	=cut
105
106	sub _build_headers {
107	my ( $self, $items ) = @_;
108
109	my @witness_attributes = uniq map {
110	my $item = $_;
111	map { defined $item->{$_} && $item->{$_} ne "" ? $_ : () } keys %$item
112	} @$items;
113
114	my ( $itemtag, $itemsubfield ) =
115	C4::Biblio::GetMarcFromKohaField("items.itemnumber");
116	my $tagslib = C4::Biblio::GetMarcStructure(1);
117	my $subfieldcode_attribute_mappings;
118	for my $subfield_code ( keys %{ $tagslib->{$itemtag} } ) {
119
120	my $subfield = $tagslib->{$itemtag}->{$subfield_code};
121
122	next if IsMarcStructureInternal($subfield);
123	next unless $subfield->{tab} eq 10; # Is this really needed?
124
125	my $attribute;
126	if ( $subfield->{kohafield} ) {
127	( $attribute = $subfield->{kohafield} ) =~ s\|^items\.\|\|;
128	}
129	else {
130	$attribute = $subfield_code; # It's in more_subfields_xml
131	}
132	next unless grep { $attribute eq $_ } @witness_attributes;
133	$subfieldcode_attribute_mappings->{$subfield_code} = $attribute;
134	}
135
136	return [
137	map {
138	{
139	header_value => $tagslib->{$itemtag}->{$_}->{lib},
140	attribute => $subfieldcode_attribute_mappings->{$_},
141	subfield_code => $_,
142	}
143	} sort keys %$subfieldcode_attribute_mappings
144	];
145	}
146
147	1

Lines 46-64 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/includes/background_jobs/batch_biblio_record_modification.inc (-14 / +16 lines)
46	[% END %]	46	[% END %]
47		47
48	[% BLOCK js %]	48	[% BLOCK js %]
49	$("#add_bibs_to_list").change(function(){	49	<script>
50	var selected = $("#add_bibs_to_list").find("option:selected");	50	$("#add_bibs_to_list").change(function(){
51	if ( selected.attr("class") == "shelf" ){	51	var selected = $("#add_bibs_to_list").find("option:selected");
52	var shelfnumber = selected.attr("value");	52	if ( selected.attr("class") == "shelf" ){
53	var bibs = new Array();	53	var shelfnumber = selected.attr("value");
54	[% FOREACH message IN job.messages %]	54	var bibs = new Array();
55	[% IF message.code == 'biblio_modified' %]	55	[% FOREACH message IN job.messages %]
56	bibs.push("biblionumber="+[% message.biblionumber \| html %]);	56	[% IF message.code == 'biblio_modified' %]
		57	bibs.push("biblionumber="+[% message.biblionumber \| html %]);
		58	[% END %]
57	[% END %]	59	[% END %]
58	[% END %]	60	var bibstring = bibs.join("&");
59	var bibstring = bibs.join("&");	61	window.open('/cgi-bin/koha/virtualshelves/addbybiblionumber.pl?shelfnumber='+shelfnumber+'&confirm=1&'+bibstring, 'popup', 'width=500,height=500,toolbar=false,scrollbars=yes,resizable=yes');
60	window.open('/cgi-bin/koha/virtualshelves/addbybiblionumber.pl?shelfnumber='+shelfnumber+'&confirm=1&'+bibstring, 'popup', 'width=500,height=500,toolbar=false,scrollbars=yes,resizable=yes');	62	return false;
61	return false;	63	}
62	}	64	});
63	});	65	</script>
64	[% END %]	66	[% END %]

Line 0 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/includes/background_jobs/batch_item_record_deletion.inc (+58 lines)
	1	[% BLOCK report %]
	2	[% SET report = job.report %]
	3	[% IF report %]
	4	<div class="dialog message">
	5	[% IF report.deleted_itemnumbers.size %]
	6	<p>[% report.deleted_itemnumbers.size \| html %] item(s) deleted.</p>
	7	[% IF report.deleted_biblionumbers.size %]
	8	<p>[% report.deleted_biblionumbers.size \| html %] record(s) deleted.</p>
	9	[% END %]
	10	[% ELSE %]
	11	No items deleted.
	12	[% END %]
	13	</div>
	14
	15	[% IF report.not_deleted_itemnumbers.size %]
	16	<div class="dialog error">
	17	[% report.not_deleted_itemnumbers.size \| html %] item(s) could not be deleted: [% FOREACH not_deleted_itemnumber IN not_deleted_itemnumbers %][% not_deleted_itemnumber.itemnumber \| html %][% END %]
	18	</div>
	19	[% END %]
	20
	21	[% IF job.status == 'cancelled' %]
	22	<div class="dialog error">
	23	The job has been cancelled before it finished.
	24	<a href="/cgi-bin/koha/tools/batchMod.pl" title="New batch item modification">New batch item modification</a>
	25	</div>
	26	[% END %]
	27	[% END %]
	28	[% END %]
	29
	30	[% BLOCK detail %]
	31	[% FOR m IN job.messages %]
	32	<div class="dialog message">
	33	[% IF m.type == 'success' %]
	34	<i class="fa fa-check success"></i>
	35	[% ELSIF m.type == 'warning' %]
	36	<i class="fa fa-warning warn"></i>
	37	[% ELSIF m.type == 'error' %]
	38	<i class="fa fa-exclamation error"></i>
	39	[% END %]
	40	[% SWITCH m.code %]
	41	[% CASE 'item_not_deleted' %]
	42	Item with barcode <a href="/cgi-bin/koha/catalogue/moredetail.pl?biblionumber=[% m.biblionumber \| uri %]&itemnumber=[% m.itemnumber \| uri %]">[% m.barcode \| html %]</a> cannot be deleted:
	43	[% SWITCH m.reason %]
	44	[% CASE "book_on_loan" %]Item is checked out
	45	[% CASE "not_same_branch" %]Item does not belong to your library
	46	[% CASE "book_reserved" %]Item has a waiting hold
	47	[% CASE "linked_analytics" %]Item has linked analytics
	48	[% CASE "last_item_for_hold" %]Last item for bibliographic record with biblio-level hold on it
	49	[% CASE %]Unknown reason '[% m.reason \| html %]'
	50	[% END %]
	51	[% CASE %]Unknown message '[% m.code \| html %]'
	52	[% END %]
	53	</div>
	54	[% END %]
	55	[% END %]
	56
	57	[% BLOCK js %]
	58	[% END %]

Lines 1-4 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/admin/background_jobs.tt (-21 / +24 lines)
1	[% USE raw %]	1	[% USE raw %]
		2	[% USE KohaDates %]
2	[% USE Asset %]	3	[% USE Asset %]
3	[% USE KohaDates %]	4	[% USE KohaDates %]
4	[% SET footerjs = 1 %]	5	[% SET footerjs = 1 %]
Lines 19-34 Link Here
19	[% END -%]	20	[% END -%]
20	[% END %]	21	[% END %]
21	[% BLOCK show_job_type %]	22	[% BLOCK show_job_type %]
22	[% SWITCH job.type %]	23	[% SWITCH job_type %]
23	[% CASE "batch_biblio_record_modification" %]	24	[% CASE 'batch_biblio_record_modification' %]
24	Batch bibliographic record modification	25	Batch bibliographic record modification
25	[% CASE "batch_authority_record_modification" %]	26	[% CASE 'batch_biblio_record_deletion' %]
26	Batch authority record modification	27	Batch bibliographic record record deletion
27	[% CASE "batch_hold_cancel" %]	28	[% CASE 'batch_authority_record_modification' %]
28	Batch hold cancellation	29	Batch authority record modification
29	[% CASE # Default case %]	30	[% CASE 'batch_authority_record_deletion' %]
30	[% job.type \| html %]	31	Batch authority record deletion
		32	[% CASE 'batch_item_record_modification' %]
		33	Batch item record modification
		34	[% CASE 'batch_item_record_deletion' %]
		35	Batch item record deletion
		36	[% CASE "batch_hold_cancel" %]
		37	Batch hold cancellation
		38	[% CASE %]Unknown job type '[% job_type \| html %]'
31	[% END %]	39	[% END %]
		40
32	[% END %]	41	[% END %]
33	[% INCLUDE 'doc-head-open.inc' %]	42	[% INCLUDE 'doc-head-open.inc' %]
34	<title>	43	<title>
Lines 107-113 Link Here
107	<li><label for="job_progress">Progress: </label>[% job.progress \|\| 0 \| html %] / [% job.size \| html %]</li>	116	<li><label for="job_progress">Progress: </label>[% job.progress \|\| 0 \| html %] / [% job.size \| html %]</li>
108	<li>	117	<li>
109	<label for="job_type">Type: </label>	118	<label for="job_type">Type: </label>
110	[% PROCESS show_job_type %]	119	[% PROCESS show_job_type job_type => job.type %]
111	</li>	120	</li>
112	<li>	121	<li>
113	<label for="job_enqueued_on">Queued: </label>	122	<label for="job_enqueued_on">Queued: </label>
Lines 164-177 Link Here
164	</td>	173	</td>
165	<td>[% job.progress \|\| 0 \| html %] / [% job.size \| html %]</td>	174	<td>[% job.progress \|\| 0 \| html %] / [% job.size \| html %]</td>
166	<td>	175	<td>
167	[% SWITCH job.type %]	176	[% PROCESS show_job_type job_type => job.type %]
168	[% CASE 'batch_biblio_record_modification' %]Batch bibliographic record modification
169	[% CASE 'batch_biblio_record_deletion' %]Batch bibliographic record record deletion
170	[% CASE 'batch_authority_record_modification' %]Batch authority record modification
171	[% CASE 'batch_authority_record_deletion' %]Batch authority record deletion
172	[% CASE "batch_hold_cancel" %]Batch hold cancellation
173	[% CASE %][% job.type \| html %]
174	[% END %]
175	</td>	177	</td>
176	<td>[% job.enqueued_on \| $KohaDates with_hours = 1 %]</td>	178	<td>[% job.enqueued_on \| $KohaDates with_hours = 1 %]</td>
177	<td>[% job.started_on\| $KohaDates with_hours = 1 %]</td>	179	<td>[% job.started_on\| $KohaDates with_hours = 1 %]</td>
Lines 217-226 Link Here
217	"sPaginationType": "full_numbers"	219	"sPaginationType": "full_numbers"
218	}));	220	}));
219		221
220	[% IF op == 'view' %]
221	[% PROCESS 'js' %]
222	[% END %]
223	});	222	});
224	</script>	223	</script>
		224	[% IF op == 'view' %]
		225	[% PROCESS 'js' %]
		226	[% END %]
225	[% END %]	227	[% END %]
		228
226	[% INCLUDE 'intranet-bottom.inc' %]	229	[% INCLUDE 'intranet-bottom.inc' %]

Lines 3-16 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/js/pages/batchMod.js (-5 / +21 lines)
3	var date = new Date();	3	var date = new Date();
4	date.setTime(date.getTime() + (365 * 24 * 60 * 60 * 1000));	4	date.setTime(date.getTime() + (365 * 24 * 60 * 60 * 1000));
5		5
		6	function guess_nb_cols() {
		7	// This is a bit ugly, we are trying to know if there are checkboxes in the first column of the table
		8	if ( $("#itemst tr:first th:first").html() == "" ) {
		9	// First header is empty, it's a checkbox
		10	return 3;
		11	} else {
		12	// First header is not empty, there are no checkboxes
		13	return 2;
		14	}
		15	}
		16
6	function hideColumns() {	17	function hideColumns() {
7	var valCookie = Cookies.get("showColumns");	18	var valCookie = Cookies.get("showColumns");
		19	var nb_cols = guess_nb_cols();
8	if (valCookie) {	20	if (valCookie) {
9	valCookie = valCookie.split("/");	21	valCookie = valCookie.split("/");
10	$("#showall").prop("checked", false).parent().removeClass("selected");	22	$("#showall").prop("checked", false).parent().removeClass("selected");
11	for ( var i = 0; i < valCookie.length; i++ ) {	23	for ( var i = 0; i < valCookie.length; i++ ) {
12	if (valCookie[i] !== '') {	24	if (valCookie[i] !== '') {
13	var index = valCookie[i] - 3;	25	var index = valCookie[i] - nb_cols;
14	$("#itemst td:nth-child(" + valCookie[i] + "),#itemst th:nth-child(" + valCookie[i] + ")").toggle();	26	$("#itemst td:nth-child(" + valCookie[i] + "),#itemst th:nth-child(" + valCookie[i] + ")").toggle();
15	$("#checkheader" + index).prop("checked", false).parent().removeClass("selected");	27	$("#checkheader" + index).prop("checked", false).parent().removeClass("selected");
16	}	28	}
Lines 20-29 function hideColumns() { Link Here
20		32
21	function hideColumn(num) {	33	function hideColumn(num) {
22	$("#hideall,#showall").prop("checked", false).parent().removeClass("selected");	34	$("#hideall,#showall").prop("checked", false).parent().removeClass("selected");
		35	var nb_cols = guess_nb_cols();
23	var valCookie = Cookies.get("showColumns");	36	var valCookie = Cookies.get("showColumns");
24	// set the index of the table column to hide	37	// set the index of the table column to hide
25	$("#" + num).parent().removeClass("selected");	38	$("#" + num).parent().removeClass("selected");
26	var hide = Number(num.replace("checkheader", "")) + 3;	39	var hide = Number(num.replace("checkheader", "")) + nb_cols;
27	// hide header and cells matching the index	40	// hide header and cells matching the index
28	$("#itemst td:nth-child(" + hide + "),#itemst th:nth-child(" + hide + ")").toggle();	41	$("#itemst td:nth-child(" + hide + "),#itemst th:nth-child(" + hide + ")").toggle();
29	// set or modify cookie with the hidden column's index	42	// set or modify cookie with the hidden column's index
Lines 59-65 function showColumn(num) { Link Here
59	$("#" + num).parent().addClass("selected");	72	$("#" + num).parent().addClass("selected");
60	var valCookie = Cookies.get("showColumns");	73	var valCookie = Cookies.get("showColumns");
61	// set the index of the table column to hide	74	// set the index of the table column to hide
62	var show = Number(num.replace("checkheader", "")) + 3;	75	var nb_cols = guess_nb_cols();
		76	var show = Number(num.replace("checkheader", "")) + nb_cols;
63	// hide header and cells matching the index	77	// hide header and cells matching the index
64	$("#itemst td:nth-child(" + show + "),#itemst th:nth-child(" + show + ")").toggle();	78	$("#itemst td:nth-child(" + show + "),#itemst th:nth-child(" + show + ")").toggle();
65	// set or modify cookie with the hidden column's index	79	// set or modify cookie with the hidden column's index
Lines 80-100 function showColumn(num) { Link Here
80	}	94	}
81		95
82	function showAllColumns() {	96	function showAllColumns() {
		97	var nb_cols = guess_nb_cols();
83	$("#selections input:checkbox").each(function () {	98	$("#selections input:checkbox").each(function () {
84	$(this).prop("checked", true);	99	$(this).prop("checked", true);
85	});	100	});
86	$("#selections span").addClass("selected");	101	$("#selections span").addClass("selected");
87	$("#itemst td:nth-child(3),#itemst tr th:nth-child(3)").nextAll().show();	102	$("#itemst td:nth-child("+nb_cols+"),#itemst tr th:nth-child("+nb_cols+")").nextAll().show();
88	$.removeCookie("showColumns", { path: '/' });	103	$.removeCookie("showColumns", { path: '/' });
89	$("#hideall").prop("checked", false).parent().removeClass("selected");	104	$("#hideall").prop("checked", false).parent().removeClass("selected");
90	}	105	}
91		106
92	function hideAllColumns() {	107	function hideAllColumns() {
		108	var nb_cols = guess_nb_cols();
93	$("#selections input:checkbox").each(function () {	109	$("#selections input:checkbox").each(function () {
94	$(this).prop("checked", false);	110	$(this).prop("checked", false);
95	});	111	});
96	$("#selections span").removeClass("selected");	112	$("#selections span").removeClass("selected");
97	$("#itemst td:nth-child(3),#itemst th:nth-child(3)").nextAll().hide();	113	$("#itemst td:nth-child("+nb_cols+"),#itemst tr th:nth-child("+nb_cols+")").nextAll().hide();
98	$("#hideall").prop("checked", true).parent().addClass("selected");	114	$("#hideall").prop("checked", true).parent().addClass("selected");
99	var cookieString = allColumns.join("/");	115	var cookieString = allColumns.join("/");
100	Cookies.set("showColumns", cookieString, { expires: date, path: '/' });	116	Cookies.set("showColumns", cookieString, { expires: date, path: '/' });

Lines 109-119 subtest 'has_pending_hold() tests' => sub { Link Here

(-)a/t/db_dependent/Koha/Item.t (-5 / +17 lines)
109	subtest "as_marc_field() tests" => sub {	109	subtest "as_marc_field() tests" => sub {
110		110
111	my $mss = C4::Biblio::GetMarcSubfieldStructure( '' );	111	my $mss = C4::Biblio::GetMarcSubfieldStructure( '' );
		112	my ( $itemtag, $itemtagsubfield) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );
112		113
113	my @schema_columns = $schema->resultset('Item')->result_source->columns;	114	my @schema_columns = $schema->resultset('Item')->result_source->columns;
114	my @mapped_columns = grep { exists $mss->{'items.'.$_} } @schema_columns;	115	my @mapped_columns = grep { exists $mss->{'items.'.$_} } @schema_columns;
115		116
116	plan tests => 2 * (scalar @mapped_columns + 1) + 2;	117	plan tests => 2 * (scalar @mapped_columns + 1) + 3;
117		118
118	$schema->storage->txn_begin;	119	$schema->storage->txn_begin;
119		120
Lines 126-132 subtest "as_marc_field() tests" => sub { Link Here
126		127
127	is(	128	is(
128	$marc_field->tag,	129	$marc_field->tag,
129	$mss->{'items.itemnumber'}[0]->{tagfield},	130	$itemtag,
130	'Generated field set the right tag number'	131	'Generated field set the right tag number'
131	);	132	);
132		133
Lines 141-147 subtest "as_marc_field() tests" => sub { Link Here
141		142
142	is(	143	is(
143	$marc_field->tag,	144	$marc_field->tag,
144	$mss->{'items.itemnumber'}[0]->{tagfield},	145	$itemtag,
145	'Generated field set the right tag number'	146	'Generated field set the right tag number'
146	);	147	);
147		148
Lines 154-178 subtest "as_marc_field() tests" => sub { Link Here
154	my $unmapped_subfield = Koha::MarcSubfieldStructure->new(	155	my $unmapped_subfield = Koha::MarcSubfieldStructure->new(
155	{	156	{
156	frameworkcode => '',	157	frameworkcode => '',
157	tagfield => $mss->{'items.itemnumber'}[0]->{tagfield},	158	tagfield => $itemtag,
158	tagsubfield => 'X',	159	tagsubfield => 'X',
159	}	160	}
160	)->store;	161	)->store;
161		162
162	$mss = C4::Biblio::GetMarcSubfieldStructure( '' );
163	my @unlinked_subfields;	163	my @unlinked_subfields;
164	push @unlinked_subfields, X => 'Something weird';	164	push @unlinked_subfields, X => 'Something weird';
165	$item->more_subfields_xml( C4::Items::_get_unlinked_subfields_xml( \@unlinked_subfields ) )->store;	165	$item->more_subfields_xml( C4::Items::_get_unlinked_subfields_xml( \@unlinked_subfields ) )->store;
166		166
		167	Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );
		168	Koha::MarcSubfieldStructures->search(
		169	{ frameworkcode => '', tagfield => $itemtag } )
		170	->update( { display_order => \['FLOOR( 1 + RAND( ) * 10 )'] } );
		171
167	$marc_field = $item->as_marc_field;	172	$marc_field = $item->as_marc_field;
168		173
		174	my $tagslib = C4::Biblio::GetMarcStructure(1, '');
169	my @subfields = $marc_field->subfields;	175	my @subfields = $marc_field->subfields;
170	my $result = all { defined $_->[1] } @subfields;	176	my $result = all { defined $_->[1] } @subfields;
171	ok( $result, 'There are no undef subfields' );	177	ok( $result, 'There are no undef subfields' );
		178	my @ordered_subfields = sort {
		179	$tagslib->{$itemtag}->{ $a->[0] }->{display_order}
		180	<=> $tagslib->{$itemtag}->{ $b->[0] }->{display_order}
		181	} @subfields;
		182	is_deeply(\@subfields, \@ordered_subfields);
172		183
173	is( scalar $marc_field->subfield('X'), 'Something weird', 'more_subfield_xml is considered' );	184	is( scalar $marc_field->subfield('X'), 'Something weird', 'more_subfield_xml is considered' );
174		185
175	$schema->storage->txn_rollback;	186	$schema->storage->txn_rollback;
		187	Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );
176	};	188	};
177		189
178	subtest 'pickup_locations' => sub {	190	subtest 'pickup_locations' => sub {

Line 0 Link Here

(-)a/t/db_dependent/Koha/Item/Attributes.t (+151 lines)
		1	#!/usr/bin/perl
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19	use Test::More tests=> 10;
		20	use utf8;
		21
		22	use Koha::Database;
		23	use Koha::Caches;
		24
		25	use C4::Biblio;
		26	use Koha::Item::Attributes;
		27	use Koha::MarcSubfieldStructures;
		28
		29	use t::lib::TestBuilder;
		30
		31	my $schema = Koha::Database->new->schema;
		32	$schema->storage->txn_begin;
		33
		34	my $builder = t::lib::TestBuilder->new;
		35	my $biblio = $builder->build_sample_biblio({ frameworkcode => '' });
		36	my $item = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
		37
		38	my $cache = Koha::Caches->get_instance;
		39	$cache->clear_from_cache("MarcStructure-0-");
		40	$cache->clear_from_cache("MarcStructure-1-");
		41	$cache->clear_from_cache("default_value_for_mod_marc-");
		42	$cache->clear_from_cache("MarcSubfieldStructure-");
		43
		44	# 952 $x $é $y are not linked with a kohafield
		45	# $952$x $é repeatable
		46	# $952$y is not repeatable
		47	setup_mss();
		48
		49	$item->more_subfields_xml(undef)->store; # Shouldn't be needed, but we want to make sure
		50	my $attributes = $item->additional_attributes;
		51	is( ref($attributes), 'Koha::Item::Attributes' );
		52	is( $attributes->to_marcxml, undef );
		53	is_deeply($attributes->to_hashref, {});
		54
		55	my $some_marc_xml = q{<?xml version="1.0" encoding="UTF-8"?>
		56	<collection
		57	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		58	xsi:schemaLocation="http://www.loc.gov/MARC21/slim http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd"
		59	xmlns="http://www.loc.gov/MARC21/slim">
		60
		61	<record>
		62	<leader> a </leader>
		63	<datafield tag="999" ind1=" " ind2=" ">
		64	<subfield code="x">value for x 1</subfield>
65	<subfield code="x">value for x 2</subfield>
66	<subfield code="y">value for y</subfield>
67	<subfield code="é">value for é 1</subfield>
68	<subfield code="é">value for é 2</subfield>
69	<subfield code="z">value for z 1\|value for z 2</subfield>
70	</datafield>
71	</record>
72
73	</collection>};
74
75	$item->more_subfields_xml($some_marc_xml)->store;
76
77	$attributes = $item->additional_attributes;
78	is( ref($attributes), 'Koha::Item::Attributes' );
79	is( $attributes->{'x'}, "value for x 1\|value for x 2");
80	is( $attributes->{'y'}, "value for y");
81	is( $attributes->{'é'}, "value for é 1\|value for é 2");
82	is( $attributes->{'z'}, "value for z 1\|value for z 2");
83
84	is( $attributes->to_marcxml, $some_marc_xml );
85	is_deeply(
86	$attributes->to_hashref,
87	{
88	'x' => "value for x 1\|value for x 2",
89	'y' => "value for y",
90	'é' => "value for é 1\|value for é 2",
91	'z' => "value for z 1\|value for z 2",
92	}
93	);
94
95	Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );
96
97	sub setup_mss {
98
99	my ( $itemtag, $itemsubfield ) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );
100
101	Koha::MarcSubfieldStructures->search(
102	{
103	frameworkcode => '',
104	tagfield => $itemtag,
105	tagsubfield => 'é',
106	}
107	)->delete; # In case it exist already
108
109	Koha::MarcSubfieldStructure->new(
110	{
111	frameworkcode => '',
112	tagfield => $itemtag,
113	tagsubfield => 'é',
114	kohafield => undef,
115	repeatable => 1,
116	tab => 10,
117	}
118	)->store;
119
120	Koha::MarcSubfieldStructures->search(
121	{
122	frameworkcode => '',
123	tagfield => $itemtag,
124	tagsubfield => [ 'x', 'y' ]
125	}
126	)->update( { kohafield => undef } );
127
128	Koha::MarcSubfieldStructures->search(
129	{
130	frameworkcode => '',
131	tagfield => $itemtag,
132	tagsubfield => [ 'x', 'é' ],
133	}
134	)->update( { repeatable => 1 } );
135
136	Koha::MarcSubfieldStructures->search(
137	{
138	frameworkcode => '',
139	tagfield => $itemtag,
140	tagsubfield => ['y'],
141	}
142	)->update( { repeatable => 0 } );
143
144	my $i = 0;
145	for my $sf ( qw( x y é z ) ) {
146	Koha::MarcSubfieldStructures->search(
147	{ frameworkcode => '', tagfield => $itemtag, tagsubfield => $sf } )
148	->update( { display_order => $i++ } );
149	}
150
151	}

Line 0 Link Here

(-)a/t/db_dependent/Koha/Items/BatchUpdate.t (+383 lines)
		1	#!/usr/bin/perl
		2
		3	# This file is part of Koha.
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19	use Test::More tests=> 7;
		20	use utf8;
		21
		22	use Koha::Database;
		23	use Koha::Caches;
		24
		25	use C4::Biblio;
		26	use Koha::Item::Attributes;
		27	use Koha::MarcSubfieldStructures;
		28
		29	use t::lib::TestBuilder;
		30
		31	my $schema = Koha::Database->new->schema;
		32	$schema->storage->txn_begin;
		33
		34	my $builder = t::lib::TestBuilder->new;
		35
		36	Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );
		37
		38	# 952 $x $é $y are not linked with a kohafield
		39	# $952$x $é repeatable
		40	# $952$t is not repeatable
		41	# 952$z is linked with items.itemnotes and is repeatable
		42	# 952$t is linked with items.copynumber and is not repeatable
		43	setup_mss();
		44
		45	my $biblio = $builder->build_sample_biblio({ frameworkcode => '' });
		46	my $item = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
		47
		48	my $items = Koha::Items->search({itemnumber => $item->itemnumber});
		49
		50	subtest 'MARC subfield linked with kohafield' => sub {
		51	plan tests => 9;
		52
		53	$items->batch_update({
		54	new_values => {itemnotes => 'new note'}
		55	});
		56	$items->reset;
		57
		58	$item = $item->get_from_storage;
		59	is( $item->itemnotes, 'new note' );
		60	is( $item->as_marc_field->subfield('t'), undef );
		61
		62	is( $items->batch_update({
		63	new_values => {itemnotes=> 'another note'}
		64	})->count, 1, 'Can be chained');
65	$items->reset;
66
67	$items->batch_update({new_values => {itemnotes=> undef }})->reset;
68	$item = $item->get_from_storage;
69	is( $item->itemnotes, undef, "blank" );
70	is( $item->as_marc_field->subfield('t'), undef, '' );
71
72	$items->batch_update({new_values => {itemnotes=> 'new note', copynumber => 'new copynumber'}})->reset;
73	$item = $item->get_from_storage;
74	is( $item->itemnotes, 'new note', "multi" );
75	is( $item->as_marc_field->subfield('z'), 'new note', '' );
76	is( $item->copynumber, 'new copynumber', "multi" );
77	is( $item->as_marc_field->subfield('t'), 'new copynumber', '' );
78	};
79
80	subtest 'More marc subfields (no linked)' => sub {
81	plan tests => 1;
82
83	$items->batch_update({new_values => {x => 'new xxx' }})->reset;
84	is( $item->get_from_storage->as_marc_field->subfield('x'), 'new xxx' );
85	};
86
87	subtest 'repeatable' => sub {
88	plan tests => 2;
89
90	subtest 'linked' => sub {
91	plan tests => 4;
92
93	$items->batch_update({new_values => {itemnotes => 'new zzz 1\|new zzz 2' }})->reset;
94	is( $item->get_from_storage->itemnotes, 'new zzz 1\|new zzz 2');
95	is_deeply( [$item->get_from_storage->as_marc_field->subfield('z')], ['new zzz 1', 'new zzz 2'], 'z is repeatable' );
96
97	$items->batch_update({new_values => {copynumber => 'new ttt 1\|new ttt 2' }})->reset;
98	is( $item->get_from_storage->copynumber, 'new ttt 1\|new ttt 2');
99	is_deeply( [$item->get_from_storage->as_marc_field->subfield('t')], ['new ttt 1\|new ttt 2'], 't is not repeatable' );
100	};
101
102	subtest 'not linked' => sub {
103	plan tests => 2;
104
105	$items->batch_update({new_values => {x => 'new xxx 1\|new xxx 2' }})->reset;
106	is_deeply( [$item->get_from_storage->as_marc_field->subfield('x')], ['new xxx 1', 'new xxx 2'], 'i is repeatable' );
107
108	$items->batch_update({new_values => {y => 'new yyy 1\|new yyy 2' }})->reset;
109	is_deeply( [$item->get_from_storage->as_marc_field->subfield('y')], ['new yyy 1\|new yyy 2'], 'y is not repeatable' );
110	};
111	};
112
113	subtest 'blank' => sub {
114	plan tests => 5;
115
116	$items->batch_update(
117	{
118	new_values => {
119	itemnotes => 'new notes 1\|new notes 2',
120	copynumber => 'new cn 1\|new cn 2',
121	x => 'new xxx 1\|new xxx 2',
122	y => 'new yyy 1\|new yyy 2',
123
124	}
125	}
126	)->reset;
127
128	$items->batch_update(
129	{
130	new_values => {
131	itemnotes => undef,
132	copynumber => undef,
133	x => undef,
134	}
135	}
136	)->reset;
137
138	$item = $item->get_from_storage;
139	is( $item->itemnotes, undef );
140	is( $item->copynumber, undef );
141	is( $item->as_marc_field->subfield('x'), undef );
142	is_deeply( [ $item->as_marc_field->subfield('y') ],
143	['new yyy 1\|new yyy 2'] );
144
145	$items->batch_update(
146	{
147	new_values => {
148	y => undef,
149	}
150	}
151	)->reset;
152
153	is( $item->get_from_storage->more_subfields_xml, undef );
154
155	};
156
157	subtest 'regex' => sub {
158	plan tests => 6;
159
160	$items->batch_update(
161	{
162	new_values => {
163	itemnotes => 'new notes 1\|new notes 2',
164	copynumber => 'new cn 1\|new cn 2',
165	x => 'new xxx 1\|new xxx 2',
166	y => 'new yyy 1\|new yyy 2',
167
168	}
169	}
170	)->reset;
171
172	my $re = {
173	search => 'new',
174	replace => 'awesome',
175	modifiers => '',
176	};
177	$items->batch_update(
178	{
179	regex_mod =>
180	{ itemnotes => $re, copynumber => $re, x => $re, y => $re }
181	}
182	)->reset;
183	$item = $item->get_from_storage;
184	is( $item->itemnotes, 'awesome notes 1\|new notes 2' );
185	is_deeply(
186	[ $item->as_marc_field->subfield('z') ],
187	[ 'awesome notes 1', 'new notes 2' ],
188	'z is repeatable'
189	);
190
191	is( $item->copynumber, 'awesome cn 1\|new cn 2' );
192	is_deeply( [ $item->as_marc_field->subfield('t') ],
193	['awesome cn 1\|new cn 2'], 't is not repeatable' );
194
195	is_deeply(
196	[ $item->as_marc_field->subfield('x') ],
197	[ 'awesome xxx 1', 'new xxx 2' ],
198	'i is repeatable'
199	);
200
201	is_deeply(
202	[ $item->as_marc_field->subfield('y') ],
203	['awesome yyy 1\|new yyy 2'],
204	'y is not repeatable'
205	);
206	};
207
208	subtest 'encoding' => sub {
209	plan tests => 1;
210
211	$items->batch_update({
212	new_values => { 'é' => 'new note é'}
213	});
214	$items->reset;
215
216	$item = $item->get_from_storage;
217	is( $item->as_marc_field->subfield('é'), 'new note é', );
218	};
219
220	subtest 'report' => sub {
221	plan tests => 5;
222
223	my $item_1 =
224	$builder->build_sample_item( { biblionumber => $biblio->biblionumber } );
225	my $item_2 =
226	$builder->build_sample_item( { biblionumber => $biblio->biblionumber } );
227
228	my $items = Koha::Items->search(
229	{ itemnumber => [ $item_1->itemnumber, $item_2->itemnumber ] } );
230
231	my ($report) = $items->batch_update(
232	{
233	new_values => { itemnotes => 'new note' }
234	}
235	);
236	$items->reset;
237	is_deeply(
238	$report,
239	{
240	modified_itemnumbers =>
241	[ $item_1->itemnumber, $item_2->itemnumber ],
242	modified_fields => 2
243	}
244	);
245
246	($report) = $items->batch_update(
247	{
248	new_values => { itemnotes => 'new note', copynumber => 'new cn' }
249	}
250	);
251	$items->reset;
252
253	is_deeply(
254	$report,
255	{
256	modified_itemnumbers =>
257	[ $item_1->itemnumber, $item_2->itemnumber ],
258	modified_fields => 2
259	}
260	);
261
262	$item_1->get_from_storage->update( { itemnotes => 'not new note' } );
263	($report) = $items->batch_update(
264	{
265	new_values => { itemnotes => 'new note', copynumber => 'new cn' }
266	}
267	);
268	$items->reset;
269
270	is_deeply(
271	$report,
272	{
273	modified_itemnumbers => [ $item_1->itemnumber ],
274	modified_fields => 1
275	}
276	);
277
278	($report) = $items->batch_update(
279	{
280	new_values => { x => 'new xxx', y => 'new yyy' }
281	}
282	);
283	$items->reset;
284
285	is_deeply(
286	$report,
287	{
288	modified_itemnumbers =>
289	[ $item_1->itemnumber, $item_2->itemnumber ],
290	modified_fields => 4
291	}
292	);
293
294	my $re = {
295	search => 'new',
296	replace => 'awesome',
297	modifiers => '',
298	};
299
300	$item_2->get_from_storage->update( { itemnotes => 'awesome note' } );
301	($report) = $items->batch_update(
302	{
303	regex_mod =>
304	{ itemnotes => $re, copynumber => $re, x => $re, y => $re }
305	}
306	);
307	$items->reset;
308
309	is_deeply(
310	$report,
311	{
312	modified_itemnumbers =>
313	[ $item_1->itemnumber, $item_2->itemnumber ],
314	modified_fields => 7
315	}
316	);
317
318	};
319
320	Koha::Caches->get_instance->clear_from_cache( "MarcStructure-1-" );
321
322	sub setup_mss {
323
324	my ( $itemtag, $itemsubfield ) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );
325
326	Koha::MarcSubfieldStructures->search(
327	{
328	frameworkcode => '',
329	tagfield => $itemtag,
330	tagsubfield => 'é',
331	}
332	)->delete; # In case it exist already
333
334	Koha::MarcSubfieldStructure->new(
335	{
336	frameworkcode => '',
337	tagfield => $itemtag,
338	tagsubfield => 'é',
339	kohafield => undef,
340	repeatable => 1,
341	tab => 10,
342	}
343	)->store;
344
345	Koha::MarcSubfieldStructures->search(
346	{
347	frameworkcode => '',
348	tagfield => $itemtag,
349	tagsubfield => [ 'x', 'y' ]
350	}
351	)->update( { kohafield => undef } );
352
353	Koha::MarcSubfieldStructures->search(
354	{
355	frameworkcode => '',
356	tagfield => $itemtag,
357	tagsubfield => [ 'x', 'é' ],
358	}
359	)->update( { repeatable => 1 } );
360
361	Koha::MarcSubfieldStructures->search(
362	{
363	frameworkcode => '',
364	tagfield => $itemtag,
365	tagsubfield => ['t'],
366	}
367	)->update( { repeatable => 0 } );
368
369	Koha::MarcSubfieldStructures->search(
370	{
371	frameworkcode => '',
372	tagfield => $itemtag,
373	tagsubfield => ['z'],
374	}
375	)->update( { kohafield => 'items.itemnotes', repeatable => 1 } );
376
377	Koha::MarcSubfieldStructures->search(
378	{
379	frameworkcode => '',
380	tagfield => $itemtag,
381	}
382	)->update( { display_order => \['FLOOR( 1 + RAND( ) * 10 )'] } );
383	}

Line 0 Link Here

(-)a/t/db_dependent/Koha/UI/Form/Builder/Item.t (+329 lines)
		1	#!/usr/bin/perl
		2
		3	# This file is part of Koha
		4	#
		5	# Koha is free software; you can redistribute it and/or modify it
		6	# under the terms of the GNU General Public License as published by
		7	# the Free Software Foundation; either version 3 of the License, or
		8	# (at your option) any later version.
		9	#
		10	# Koha is distributed in the hope that it will be useful, but
		11	# WITHOUT ANY WARRANTY; without even the implied warranty of
		12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	# GNU General Public License for more details.
		14	#
		15	# You should have received a copy of the GNU General Public License
		16	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		17
		18	use Modern::Perl;
		19	use Test::More tests => 6;
		20	use utf8;
		21
		22	use List::MoreUtils qw( uniq );
		23
		24	use Koha::Libraries;
		25	use Koha::MarcSubfieldStructures;
		26	use Koha::UI::Form::Builder::Item;
		27	use t::lib::TestBuilder;
		28
		29	my $schema = Koha::Database->new->schema;
		30	$schema->storage->txn_begin;
		31
		32	my $builder = t::lib::TestBuilder->new;
		33
		34	my $cache = Koha::Caches->get_instance();
		35	$cache->clear_from_cache("MarcStructure-0-");
		36	$cache->clear_from_cache("MarcStructure-1-");
		37	$cache->clear_from_cache("default_value_for_mod_marc-");
		38	$cache->clear_from_cache("MarcSubfieldStructure-");
		39
		40	# 952 $x $é are not linked with a kohafield
		41	# $952$x $é repeatable
		42	# $952$t is not repeatable
		43	# 952$z is linked with items.itemnotes and is repeatable
		44	# 952$t is linked with items.copynumber and is not repeatable
		45	setup_mss();
		46
		47	subtest 'authorised values' => sub {
		48	#plan tests => 1;
		49
		50	my $biblio = $builder->build_sample_biblio({ value => {frameworkcode => ''}});
		51	my $subfields =
		52	Koha::UI::Form::Builder::Item->new(
		53	{ biblionumber => $biblio->biblionumber } )->edit_form;
		54
		55	my @display_orders = uniq map { $_->{display_order} } @$subfields;
		56	is_deeply( \@display_orders, [sort {$a <=> $b} @display_orders], 'subfields are sorted by display order' );
		57
		58	subtest 'normal AV' => sub {
		59	plan tests => 2;
		60	my ($subfield) =
		61	grep { $_->{kohafield} eq 'items.notforloan' } @$subfields;
		62	my $avs = Koha::AuthorisedValues->search( { category => 'NOT_LOAN' } );
		63
		64	is_deeply(
65	$subfield->{marc_value}->{values},
66	[
67	"",
68	map { $_->authorised_value }
69	sort { $a->lib cmp $b->lib }
70	$avs->as_list
71	],
72	'AVs are sorted by lib and en empty option is created first'
73	);
74	is_deeply(
75	$subfield->{marc_value}->{labels},
76	{
77	map { $_->authorised_value => $_->lib }
78	sort { $a->lib cmp $b->lib }
79	$avs->as_list
80	}
81	);
82	};
83
84	subtest 'cn_source' => sub {
85	plan tests => 2;
86	my ( $subfield ) = grep { $_->{kohafield} eq 'items.cn_source' } @$subfields;
87	is_deeply( $subfield->{marc_value}->{values}, [ '', 'ddc', 'lcc' ] );
88	is_deeply(
89	$subfield->{marc_value}->{labels},
90	{
91	ddc => "Dewey Decimal Classification",
92	lcc => "Library of Congress Classification",
93	}
94	);
95	};
96	subtest 'branches' => sub {
97	plan tests => 2;
98	my ( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
99	my $libraries = Koha::Libraries->search;
100	is_deeply(
101	$subfield->{marc_value}->{values},
102	[ $libraries->get_column('branchcode') ]
103	);
104	is_deeply(
105	$subfield->{marc_value}->{labels},
106	{ map { $_->branchcode => $_->branchname } $libraries->as_list }
107	);
108	};
109
110	subtest 'itemtypes' => sub {
111	plan tests => 2;
112	my ($subfield) = grep { $_->{kohafield} eq 'items.itype' } @$subfields;
113	my $itemtypes = Koha::ItemTypes->search;
114
115	is_deeply(
116	$subfield->{marc_value}->{values},
117	[
118	"",
119	map { $_->itemtype }
120	# We need to sort using uc or perl won't be case insensitive
121	sort { uc($a->translated_description) cmp uc($b->translated_description) }
122	$itemtypes->as_list
123	],
124	"Item types should be sorted by description and an empty entries should be shown"
125	);
126	is_deeply( $subfield->{marc_value}->{labels},
127	{ map { $_->itemtype => $_->description } $itemtypes->as_list },
128	'Labels should be correctly displayed'
129	);
130	};
131	};
132
133	subtest 'prefill_with_default_values' => sub {
134	plan tests => 2;
135
136	my $biblio = $builder->build_sample_biblio({ value => {frameworkcode => ''}});
137	my $subfields =
138	Koha::UI::Form::Builder::Item->new(
139	{ biblionumber => $biblio->biblionumber } )->edit_form;
140
141
142	my ($subfield) = grep { $_->{subfield} eq 'é' } @$subfields;
143	is( $subfield->{marc_value}->{value}, '', 'no default value if prefill_with_default_values not passed' );
144
145	$subfields =
146	Koha::UI::Form::Builder::Item->new(
147	{ biblionumber => $biblio->biblionumber } )->edit_form({ prefill_with_default_values => 1 });
148
149
150	($subfield) = grep { $_->{subfield} eq 'é' } @$subfields;
151	is( $subfield->{marc_value}->{value}, 'ééé', 'default value should be set if prefill_with_default_values passed');
152
153
154	};
155
156	subtest 'branchcode' => sub {
157	plan tests => 2;
158
159	my $biblio = $builder->build_sample_biblio({ value => {frameworkcode => ''}});
160	my $library = $builder->build_object({ class => 'Koha::Libraries' });
161	my $subfields =
162	Koha::UI::Form::Builder::Item->new(
163	{ biblionumber => $biblio->biblionumber } )->edit_form;
164
165	my ( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
166	is( $subfield->{marc_value}->{default}, '', 'no library preselected if no branchcode passed');
167
168	$subfields =
169	Koha::UI::Form::Builder::Item->new(
170	{ biblionumber => $biblio->biblionumber } )->edit_form({ branchcode => $library->branchcode });
171
172	( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
173	is( $subfield->{marc_value}->{default}, $library->branchcode, 'the correct library should be preselected if branchcode is passed');
174	};
175
176	subtest 'default_branches_empty' => sub {
177	plan tests => 2;
178
179	my $biblio = $builder->build_sample_biblio({ value => {frameworkcode => ''}});
180	my $subfields =
181	Koha::UI::Form::Builder::Item->new(
182	{ biblionumber => $biblio->biblionumber } )->edit_form;
183
184	my ( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
185	isnt( $subfield->{marc_value}->{values}->[0], "", 'No empty option for branches' );
186
187	$subfields =
188	Koha::UI::Form::Builder::Item->new(
189	{ biblionumber => $biblio->biblionumber } )->edit_form({ default_branches_empty => 1 });
190
191	( $subfield ) = grep { $_->{kohafield} eq 'items.homebranch' } @$subfields;
192	is( $subfield->{marc_value}->{values}->[0], "", 'empty option for branches if default_branches_empty passed' );
193	};
194
195	subtest 'kohafields_to_ignore' => sub {
196	plan tests => 2;
197
198	my $biblio =
199	$builder->build_sample_biblio( { value => { frameworkcode => '' } } );
200	my $subfields =
201	Koha::UI::Form::Builder::Item->new(
202	{ biblionumber => $biblio->biblionumber } )->edit_form;
203
204	my ($subfield) = grep { $_->{kohafield} eq 'items.barcode' } @$subfields;
205	isnt( $subfield, undef, 'barcode subfield should be in the subfield list' );
206
207	$subfields =
208	Koha::UI::Form::Builder::Item->new(
209	{ biblionumber => $biblio->biblionumber } )
210	->edit_form( { kohafields_to_ignore => ['items.barcode'] } );
211
212	($subfield) = grep { $_->{kohafield} eq 'items.barcode' } @$subfields;
213	is( $subfield, undef,
214	'barcode subfield should have not been built if passed to kohafields_to_ignore'
215	);
216	};
217
218	subtest 'subfields_to_allow & ignore_not_allowed_subfields' => sub {
219	plan tests => 6;
220
221	my ( $tag_cn, $subtag_cn ) = C4::Biblio::GetMarcFromKohaField("items.itemcallnumber");
222	my ( $tag_notes, $subtag_notes ) = C4::Biblio::GetMarcFromKohaField("items.itemnotes");
223	my $biblio = $builder->build_sample_biblio( { value => { frameworkcode => '' } } );
224	my $subfields =
225	Koha::UI::Form::Builder::Item->new(
226	{ biblionumber => $biblio->biblionumber } )->edit_form(
227	{
228	subfields_to_allow => [
229	sprintf( '%s$%s', $tag_cn, $subtag_cn ),
230	sprintf( '%s$%s', $tag_notes, $subtag_notes )
231	]
232	}
233	);
234
235	isnt( scalar(@$subfields), 2, "There are more than the 2 subfields we allowed" );
236	my ($subfield) = grep { $_->{kohafield} eq 'items.itemcallnumber' } @$subfields;
237	is( $subfield->{marc_value}->{readonly}, undef, "subfields to allowed are not marked as readonly" );
238	($subfield) = grep { $_->{kohafield} eq 'items.copynumber' } @$subfields;
239	isnt( $subfield->{marc_value}->{readonly}, 1, "subfields that are not in the allow list are marked as readonly" );
240
241	$subfields =
242	Koha::UI::Form::Builder::Item->new(
243	{ biblionumber => $biblio->biblionumber } )->edit_form(
244	{
245	subfields_to_allow => [
246	sprintf( '%s$%s', $tag_cn, $subtag_cn ),
247	sprintf( '%s$%s', $tag_notes, $subtag_notes )
248	],
249	ignore_not_allowed_subfields => 1,
250	}
251	);
252
253	is( scalar(@$subfields), 2, "With ignore_not_allowed_subfields, only the subfields to ignore are returned" );
254	($subfield) =
255	grep { $_->{kohafield} eq 'items.itemcallnumber' } @$subfields;
256	is( $subfield->{marc_value}->{readonly}, undef, "subfields to allowed are not marked as readonly" );
257	($subfield) = grep { $_->{kohafield} eq 'items.copynumber' } @$subfields;
258	is( $subfield, undef, "subfield that is not in the allow list is not returned" );
259	};
260
261
262	$cache->clear_from_cache("MarcStructure-0-");
263	$cache->clear_from_cache("MarcStructure-1-");
264	$cache->clear_from_cache("default_value_for_mod_marc-");
265	$cache->clear_from_cache("MarcSubfieldStructure-");
266
267	sub setup_mss {
268
269	my ( $itemtag, $itemsubfield ) = C4::Biblio::GetMarcFromKohaField( "items.itemnumber" );
270
271	Koha::MarcSubfieldStructures->search(
272	{
273	frameworkcode => '',
274	tagfield => $itemtag,
275	tagsubfield => 'é',
276	}
277	)->delete; # In case it exist already
278
279	Koha::MarcSubfieldStructure->new(
280	{
281	frameworkcode => '',
282	tagfield => $itemtag,
283	tagsubfield => 'é',
284	kohafield => undef,
285	repeatable => 1,
286	defaultvalue => 'ééé',
287	tab => 10,
288	}
289	)->store;
290
291	Koha::MarcSubfieldStructures->search(
292	{
293	frameworkcode => '',
294	tagfield => $itemtag,
295	tagsubfield => [ 'x' ]
296	}
297	)->update( { kohafield => undef } );
298
299	Koha::MarcSubfieldStructures->search(
300	{
301	frameworkcode => '',
302	tagfield => $itemtag,
303	tagsubfield => [ 'x', 'é' ],
304	}
305	)->update( { repeatable => 1 } );
306
307	Koha::MarcSubfieldStructures->search(
308	{
309	frameworkcode => '',
310	tagfield => $itemtag,
311	tagsubfield => ['t'],
312	}
313	)->update( { repeatable => 0 } );
314
315	Koha::MarcSubfieldStructures->search(
316	{
317	frameworkcode => '',
318	tagfield => $itemtag,
319	tagsubfield => ['z'],
320	}
321	)->update( { kohafield => 'items.itemnotes', repeatable => 1 } );
322
323	Koha::MarcSubfieldStructures->search(
324	{
325	frameworkcode => '',
326	tagfield => $itemtag,
327	}
328	)->update( { display_order => \['FLOOR( 1 + RAND( ) * 10 )'] } );
329	}