Attachment #135252 for bug #29333

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




      GetZ3950BatchId
      GetWebserviceBatchId
      GetImportRecordMarc
      GetImportRecordMarcXML
      GetRecordFromImportBiblio
      AddImportBatch
      GetImportBatch
      AddAuthToBatch

    return $marc, $encoding;
}

sub GetRecordFromImportBiblio {
    my ( $import_record_id, $embed_items ) = @_;

    my ($marc) = GetImportRecordMarc($import_record_id);
    my $record = MARC::Record->new_from_usmarc($marc);

    EmbedItemsInImportBiblio( $record, $import_record_id ) if $embed_items;

    return $record;
}

sub EmbedItemsInImportBiblio {
    my ( $record, $import_record_id ) = @_;
    my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber" );

    return $record;
}

=head2 GetImportRecordMarcXML

  my $marcxml = GetImportRecordMarcXML($import_record_id);

=cut

sub GetImportRecordMarcXML {
    my ($import_record_id) = @_;

    my $dbh = C4::Context->dbh;
    my $sth = $dbh->prepare("SELECT marcxml FROM import_records WHERE import_record_id = ?");
    $sth->execute($import_record_id);
    my ($marcxml) = $sth->fetchrow();
    $sth->finish();
    return $marcxml;

}

=head2 AddImportBatch

  my $batch_id = AddImportBatch($params_hash);




use Modern::Perl;

use Carp;
use MARC::Record;

use C4::Context;
use Koha::Database;

use base qw(Koha::Object);


=head1 API

=head2 Public methods

=head3 get_marc_record

Returns a MARC::Record object

    my $marc_record = $import_record->get_marc_record({ embed_items => $embed_items })

If $embed_items is true then items from import_items are embedded into the
MARC::Record returned

=cut

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

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

    my $format = $marcflavour eq 'UNIMARC' ? 'UNIMARC' : 'USMARC';
    if ($marcflavour eq 'UNIMARC' && $self->record_type eq 'auth') {
        $format = 'UNIMARCAUTH';
    }

    my $record = MARC::Record->new_from_xml($self->marcxml, $self->encoding, $format);

    if ($self->record_type eq 'biblio' && $args->{embed_items}) {
        require C4::ImportBatch;
        C4::ImportBatch::EmbedItemsInImportBiblio($record, $self->id);
    }

    return $record;
}

=head2 Internal methods

=head3 _type




use C4::Auth qw( get_template_and_user );
use C4::Output qw( output_html_with_http_headers );
use C4::AuthoritiesMarc qw( AddAuthority ModAuthority GetAuthority GetTagsLabels GetAuthMARCFromKohaField FindDuplicateAuthority );
use C4::ImportBatch qw( GetImportRecordMarc );
use C4::Context;
use Date::Calc qw( Today );
use MARC::File::USMARC;
use MARC::File::XML;
use C4::Biblio qw( TransformHtmlToMarc );
use Koha::Authority::Types;
use Koha::Import::Records;
use Koha::ItemTypes;
use vars qw( $tagslib);
use vars qw( $authorised_values_sth);


=cut

sub MARCfindbreeding_auth {
    my ( $id ) = @_;
    my ($marc, $encoding) = GetImportRecordMarc($id);
    if ($marc) {
        my $record = MARC::Record->new_from_usmarc($marc);
        if ( !defined(ref($record)) ) {
                return -1;
        } else {
            return $record, $encoding;
        }
    } else {
        return -1;
    }
}

sub build_authorized_values_list {
    my ( $tag, $subfield, $value, $dbh, $authorised_values_sth,$index_tag,$index_subfield ) = @_;


}

sub build_tabs {
    my ( $template, $record, $dbh, $input ) = @_;

    # fill arrays
    my @loop_data = ();


            # if MARC::Record is not empty =>use it as master loop, then add missing subfields that should be in the tab.
            # if MARC::Record is empty => use tab as master loop.
            if ( $record && ( $record->field($tag) || $tag eq '000' ) ) {
                my @fields;
                if ( $tag ne '000' ) {
                                @fields = $record->field($tag);

$tagslib = GetTagsLabels(1,$authtypecode);
$mandatory_z3950 = GetMandatoryFieldZ3950($authtypecode);

my $record;
my $encoding="";
if (($authid) && !($breedingid)){
    $record = GetAuthority($authid);
}
if ($breedingid) {
    my $import_record = Koha::Import::Records->find($breedingid);
    if ($import_record) {
        $record = $import_record->get_marc_record();
    }
} elsif ($authid) {
    $record = GetAuthority($authid);
}

my ($oldauthnumtagfield,$oldauthnumtagsubfield);

        exit;
    } else {
    # it may be a duplicate, warn the user and do nothing
        build_tabs($template, $record, $dbh, $input);
        build_hidden_data;
        $template->param(authid =>$authid,
                        duplicateauthid     => $duplicateauthid,

        {
                $authid = "";
        }
        build_tabs ($template, $record, $dbh, $input);
        build_hidden_data;
        $template->param(oldauthtypetagfield=>$oldauthtypetagfield, oldauthtypetagsubfield=>$oldauthtypetagsubfield,
                        oldauthnumtagfield=>$oldauthnumtagfield, oldauthnumtagsubfield=>$oldauthnumtagsubfield,

Lines 31-39 use C4::Context; Link Here

(-)a/catalogue/showmarc.pl (-5 / +16 lines)
31	use C4::Output qw( output_html_with_http_headers );	31	use C4::Output qw( output_html_with_http_headers );
32	use C4::Auth qw( get_template_and_user );	32	use C4::Auth qw( get_template_and_user );
33	use C4::Biblio qw( GetMarcBiblio GetXmlBiblio );	33	use C4::Biblio qw( GetMarcBiblio GetXmlBiblio );
34	use C4::ImportBatch qw( GetRecordFromImportBiblio );
35	use C4::XSLT;	34	use C4::XSLT;
36		35
		36	use Koha::Import::Records;
		37
37	my $input= CGI->new;	38	my $input= CGI->new;
38	my ( $template, $loggedinuser, $cookie ) = get_template_and_user(	39	my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
39	{	40	{
Lines 48-56 my $biblionumber= $input->param('id'); Link Here
48	my $importid= $input->param('importid');	49	my $importid= $input->param('importid');
49	my $view= $input->param('viewas')\|\|'';	50	my $view= $input->param('viewas')\|\|'';
50		51
		52	my $marcflavour = C4::Context->preference('marcflavour');
		53
51	my $record;	54	my $record;
		55	my $record_type = 'biblio';
		56	my $format = $marcflavour eq 'UNIMARC' ? 'UNIMARC' : 'USMARC';
52	if ($importid) {	57	if ($importid) {
53	$record = C4::ImportBatch::GetRecordFromImportBiblio( $importid, 'embed_items' );	58	my $import_record = Koha::Import::Records->find($importid);
		59	if ($import_record) {
		60	if ($marcflavour eq 'UNIMARC' && $import_record->record_type eq 'auth') {
		61	$format = 'UNIMARCAUTH';
		62	}
		63
		64	$record = $import_record->get_marc_record({ embed_items => 1 });
		65	}
54	}	66	}
55	else {	67	else {
56	$record =GetMarcBiblio({ biblionumber => $biblionumber });	68	$record =GetMarcBiblio({ biblionumber => $biblionumber });
Lines 61-71 if(!ref $record) { Link Here
61	}	73	}
62		74
63	if($view eq 'card' \|\| $view eq 'html') {	75	if($view eq 'card' \|\| $view eq 'html') {
64	my $xml = $importid ? $record->as_xml(): GetXmlBiblio($biblionumber);	76	my $xml = $importid ? $record->as_xml($format): GetXmlBiblio($biblionumber);
65	my $xsl;	77	my $xsl;
66	if ( $view eq 'card' ){	78	if ( $view eq 'card' ){
67	$xsl = C4::Context->preference('marcflavour') eq 'UNIMARC'	79	$xsl = $marcflavour eq 'UNIMARC' ? 'UNIMARC_compact.xsl' : 'compact.xsl';
68	? 'UNIMARC_compact.xsl' : 'compact.xsl';
69	}	80	}
70	else {	81	else {
71	$xsl = 'plainMARC.xsl';	82	$xsl = 'plainMARC.xsl';




use t::lib::TestBuilder;

use Koha::Database;
use Koha::Import::Records;

BEGIN {
    # Mock pluginsdir before loading Plugins module

    t::lib::Mocks::mock_config( 'pluginsdir', $path );

    use_ok('Koha::Plugins');
    use_ok('C4::ImportBatch', qw( AddImportBatch GetImportBatch AddBiblioToBatch AddItemsToImportBiblio SetMatchedBiblionumber GetImportBiblios GetItemNumbersFromImportBatch CleanBatch DeleteBatch RecordsFromMarcPlugin ));
}

# Start transaction

$record->leader('03174nam a2200445 a 4500');
$original_record->leader('03174nam a2200445 a 4500');
my ($item_tag, $item_subfield) = C4::Biblio::GetMarcFromKohaField( 'items.itemnumber' );
my @fields;
if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
    @fields = (
        MARC::Field->new(
            100, ' ', ' ',
            a => '20220520d        u||y0frey50      ba',
        ),
        MARC::Field->new(
            700, ' ', ' ',
            a => 'Knuth, Donald Ervin',
            f => '1938',
        ),
        MARC::Field->new(
            200, ' ', ' ',
            a => 'The art of computer programming',
            f => 'Donald E. Knuth.',
        ),
        MARC::Field->new(
            650, ' ', '0',
            a => 'Computer programming.',
            9 => '462',
        ),
        MARC::Field->new(
            $item_tag, ' ', ' ',
            e => 'my edition ❤',
            i => 'my item part',
        ),
        MARC::Field->new(
            $item_tag, ' ', ' ',
            e => 'my edition 2',
            i => 'my item part 2',
        ),
    );
} else {
    @fields = (
        MARC::Field->new(
            100, '1', ' ',
            a => 'Knuth, Donald Ervin',
            d => '1938',
        ),
        MARC::Field->new(
            245, '1', '4',
            a => 'The art of computer programming',
            c => 'Donald E. Knuth.',
        ),
        MARC::Field->new(
            650, ' ', '0',
            a => 'Computer programming.',
            9 => '462',
        ),
        MARC::Field->new(
            $item_tag, ' ', ' ',
            e => 'my edition ❤',
            i => 'my item part',
        ),
        MARC::Field->new(
            $item_tag, ' ', ' ',
            e => 'my edition 2',
            i => 'my item part 2',
        ),
    );
}
$record->append_fields(@fields);
$original_record->append_fields(@fields);
my $import_record_id = AddBiblioToBatch( $id_import_batch1, 0, $record, 'utf8', int(rand(99999)), 0 );
AddItemsToImportBiblio( $id_import_batch1, $import_record_id, $record, 0 );

my $import_record = Koha::Import::Records->find($import_record_id);
my $record_from_import_biblio_with_items = $import_record->get_marc_record({ embed_items => 1 });
$original_record->leader($record_from_import_biblio_with_items->leader());
is_deeply( $record_from_import_biblio_with_items, $original_record, 'Koha::Import::Record::get_marc_record should return the record with items if specified' );
my $utf8_field = $record_from_import_biblio_with_items->subfield($item_tag, 'e');
is($utf8_field, 'my edition ❤');
$original_record->delete_fields($original_record->field($item_tag)); #Remove items fields
my $record_from_import_biblio_without_items = $import_record->get_marc_record();
$original_record->leader($record_from_import_biblio_without_items->leader());
is_deeply( $record_from_import_biblio_without_items, $original_record, 'Koha::Import::Record::get_marc_record should return the record without items by default' );

my $another_biblio = $builder->build_sample_biblio;
C4::ImportBatch::SetMatchedBiblionumber( $import_record_id, $another_biblio->biblionumber );


# Test CleanBatch
C4::ImportBatch::CleanBatch( $id_import_batch3 );
$import_record = get_import_record( $id_import_batch3 );
is( $import_record, "0E0", "Batch 3 has been cleaned" );

# Test DeleteBatch


    # Create a test file
    my ( $fh, $name ) = tempfile();
    if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
        print $fh q{
003 = NLAmRIJ
100,a = 20220520d        u||y0frey50      ba
700,a = Author
200,ind2 = 0
200,a = Silence in the library
500 , a= Some note

700,a = Another
245,a = Noise in the library};
        close $fh;
    } else {
        print $fh q|
003 = NLAmRIJ
100,a = Author
245,ind2 = 0


100,a = Another
245,a = Noise in the library|;
        close $fh;
    }

    t::lib::Mocks::mock_config( 'enable_plugins', 1 );


    my $records = C4::ImportBatch::RecordsFromMarcPlugin( $name, ref $plugin, 'UTF-8' );
    is( @$records, 2, 'Two results returned' );
    is( ref $records->[0], 'MARC::Record', 'Returned MARC::Record object' );
    if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
        is( $records->[0]->subfield('200', 'a'), 'Silence in the library',
            'Checked one field in first record' );
        is( $records->[1]->subfield('700', 'a'), 'Another',
            'Checked one field in second record' );
    } else {
        is( $records->[0]->subfield('245', 'a'), 'Silence in the library',
            'Checked one field in first record' );
        is( $records->[1]->subfield('100', 'a'), 'Another',
            'Checked one field in second record' );
    }
};

subtest "_get_commit_action" => sub {




use C4::Auth qw( get_template_and_user );
use C4::Biblio qw( GetMarcBiblio );
use C4::Auth qw( get_template_and_user );
use C4::ImportBatch qw( GetImportBiblios );
use C4::AuthoritiesMarc qw( GetAuthority );

use Koha::Biblios;
use Koha::Import::Records;

# Input params
my $input        = CGI->new;

}

if( $importid ) {
    my $import_record = Koha::Import::Records->find($importid);
    my $recordImportid = $import_record->get_marc_record({ embed_items => 1 });
    $formatted2 = $recordImportid->as_formatted;
    my $biblio = GetImportBiblios($importid);
    $importTitle = $biblio->[0]->{'title'};
- 

Return to bug 29333

Lines 46-53 BEGIN { Link Here

(-)a/C4/ImportBatch.pm (-31 lines)
46	GetZ3950BatchId	46	GetZ3950BatchId
47	GetWebserviceBatchId	47	GetWebserviceBatchId
48	GetImportRecordMarc	48	GetImportRecordMarc
49	GetImportRecordMarcXML
50	GetRecordFromImportBiblio
51	AddImportBatch	49	AddImportBatch
52	GetImportBatch	50	GetImportBatch
53	AddAuthToBatch	51	AddAuthToBatch
Lines 192-208 sub GetImportRecordMarc { Link Here
192	return $marc, $encoding;	190	return $marc, $encoding;
193	}	191	}
194		192
195	sub GetRecordFromImportBiblio {
196	my ( $import_record_id, $embed_items ) = @_;
197
198	my ($marc) = GetImportRecordMarc($import_record_id);
199	my $record = MARC::Record->new_from_usmarc($marc);
200
201	EmbedItemsInImportBiblio( $record, $import_record_id ) if $embed_items;
202
203	return $record;
204	}
205
206	sub EmbedItemsInImportBiblio {	193	sub EmbedItemsInImportBiblio {
207	my ( $record, $import_record_id ) = @_;	194	my ( $record, $import_record_id ) = @_;
208	my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber" );	195	my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber" );
Lines 221-244 sub EmbedItemsInImportBiblio { Link Here
221	return $record;	208	return $record;
222	}	209	}
223		210
224	=head2 GetImportRecordMarcXML
225
226	my $marcxml = GetImportRecordMarcXML($import_record_id);
227
228	=cut
229
230	sub GetImportRecordMarcXML {
231	my ($import_record_id) = @_;
232
233	my $dbh = C4::Context->dbh;
234	my $sth = $dbh->prepare("SELECT marcxml FROM import_records WHERE import_record_id = ?");
235	$sth->execute($import_record_id);
236	my ($marcxml) = $sth->fetchrow();
237	$sth->finish();
238	return $marcxml;
239
240	}
241
242	=head2 AddImportBatch	211	=head2 AddImportBatch
243		212
244	my $batch_id = AddImportBatch($params_hash);	213	my $batch_id = AddImportBatch($params_hash);

Lines 18-24 package Koha::Import::Record; Link Here

(-)a/Koha/Import/Record.pm (+35 lines)
18	use Modern::Perl;	18	use Modern::Perl;
19		19
20	use Carp;	20	use Carp;
		21	use MARC::Record;
21		22
		23	use C4::Context;
22	use Koha::Database;	24	use Koha::Database;
23		25
24	use base qw(Koha::Object);	26	use base qw(Koha::Object);
Lines 29-34 Koha::Import::Record - Koha Import Record Object class Link Here
29		31
30	=head1 API	32	=head1 API
31		33
		34	=head2 Public methods
		35
		36	=head3 get_marc_record
		37
		38	Returns a MARC::Record object
		39
		40	my $marc_record = $import_record->get_marc_record({ embed_items => $embed_items })
		41
		42	If $embed_items is true then items from import_items are embedded into the
		43	MARC::Record returned
		44
		45	=cut
		46
		47	sub get_marc_record {
		48	my ($self, $args) = @_;
		49
		50	my $marcflavour = C4::Context->preference('marcflavour');
		51
		52	my $format = $marcflavour eq 'UNIMARC' ? 'UNIMARC' : 'USMARC';
		53	if ($marcflavour eq 'UNIMARC' && $self->record_type eq 'auth') {
		54	$format = 'UNIMARCAUTH';
		55	}
		56
		57	my $record = MARC::Record->new_from_xml($self->marcxml, $self->encoding, $format);
		58
		59	if ($self->record_type eq 'biblio' && $args->{embed_items}) {
		60	require C4::ImportBatch;
		61	C4::ImportBatch::EmbedItemsInImportBiblio($record, $self->id);
		62	}
		63
		64	return $record;
		65	}
		66
32	=head2 Internal methods	67	=head2 Internal methods
33		68
34	=head3 _type	69	=head3 _type

Lines 24-36 use CGI qw ( -utf8 ); Link Here

(-)a/authorities/authorities.pl (-26 / +12 lines)
24	use C4::Auth qw( get_template_and_user );	24	use C4::Auth qw( get_template_and_user );
25	use C4::Output qw( output_html_with_http_headers );	25	use C4::Output qw( output_html_with_http_headers );
26	use C4::AuthoritiesMarc qw( AddAuthority ModAuthority GetAuthority GetTagsLabels GetAuthMARCFromKohaField FindDuplicateAuthority );	26	use C4::AuthoritiesMarc qw( AddAuthority ModAuthority GetAuthority GetTagsLabels GetAuthMARCFromKohaField FindDuplicateAuthority );
27	use C4::ImportBatch qw( GetImportRecordMarc );
28	use C4::Context;	27	use C4::Context;
29	use Date::Calc qw( Today );	28	use Date::Calc qw( Today );
30	use MARC::File::USMARC;	29	use MARC::File::USMARC;
31	use MARC::File::XML;	30	use MARC::File::XML;
32	use C4::Biblio qw( TransformHtmlToMarc );	31	use C4::Biblio qw( TransformHtmlToMarc );
33	use Koha::Authority::Types;	32	use Koha::Authority::Types;
		33	use Koha::Import::Records;
34	use Koha::ItemTypes;	34	use Koha::ItemTypes;
35	use vars qw( $tagslib);	35	use vars qw( $tagslib);
36	use vars qw( $authorised_values_sth);	36	use vars qw( $authorised_values_sth);
Lines 48-68 builds list, depending on authorised value... Link Here
48		48
49	=cut	49	=cut
50		50
51	sub MARCfindbreeding_auth {
52	my ( $id ) = @_;
53	my ($marc, $encoding) = GetImportRecordMarc($id);
54	if ($marc) {
55	my $record = MARC::Record->new_from_usmarc($marc);
56	if ( !defined(ref($record)) ) {
57	return -1;
58	} else {
59	return $record, $encoding;
60	}
61	} else {
62	return -1;
63	}
64	}
65
66	sub build_authorized_values_list {	51	sub build_authorized_values_list {
67	my ( $tag, $subfield, $value, $dbh, $authorised_values_sth,$index_tag,$index_subfield ) = @_;	52	my ( $tag, $subfield, $value, $dbh, $authorised_values_sth,$index_tag,$index_subfield ) = @_;
68		53
Lines 329-335 sub GetMandatoryFieldZ3950 { Link Here
329	}	314	}
330		315
331	sub build_tabs {	316	sub build_tabs {
332	my ( $template, $record, $dbh, $encoding,$input ) = @_;	317	my ( $template, $record, $dbh, $input ) = @_;
333		318
334	# fill arrays	319	# fill arrays
335	my @loop_data = ();	320	my @loop_data = ();
Lines 365-371 sub build_tabs { Link Here
365		350
366	# if MARC::Record is not empty =>use it as master loop, then add missing subfields that should be in the tab.	351	# if MARC::Record is not empty =>use it as master loop, then add missing subfields that should be in the tab.
367	# if MARC::Record is empty => use tab as master loop.	352	# if MARC::Record is empty => use tab as master loop.
368	if ( $record != -1 && ( $record->field($tag) \|\| $tag eq '000' ) ) {	353	if ( $record && ( $record->field($tag) \|\| $tag eq '000' ) ) {
369	my @fields;	354	my @fields;
370	if ( $tag ne '000' ) {	355	if ( $tag ne '000' ) {
371	@fields = $record->field($tag);	356	@fields = $record->field($tag);
Lines 571-583 $template->param(nonav => $nonav,index=>$myindex,authtypecode=>$authtypecode,b Link Here
571	$tagslib = GetTagsLabels(1,$authtypecode);	556	$tagslib = GetTagsLabels(1,$authtypecode);
572	$mandatory_z3950 = GetMandatoryFieldZ3950($authtypecode);	557	$mandatory_z3950 = GetMandatoryFieldZ3950($authtypecode);
573		558
574	my $record=-1;	559	my $record;
575	my $encoding="";
576	if (($authid) && !($breedingid)){
577	$record = GetAuthority($authid);
578	}
579	if ($breedingid) {	560	if ($breedingid) {
580	( $record, $encoding ) = MARCfindbreeding_auth( $breedingid );	561	my $import_record = Koha::Import::Records->find($breedingid);
		562	if ($import_record) {
		563	$record = $import_record->get_marc_record();
		564	}
		565	} elsif ($authid) {
		566	$record = GetAuthority($authid);
581	}	567	}
582		568
583	my ($oldauthnumtagfield,$oldauthnumtagsubfield);	569	my ($oldauthnumtagfield,$oldauthnumtagsubfield);
Lines 619-625 if ($op eq "add") { Link Here
619	exit;	605	exit;
620	} else {	606	} else {
621	# it may be a duplicate, warn the user and do nothing	607	# it may be a duplicate, warn the user and do nothing
622	build_tabs($template, $record, $dbh, $encoding,$input);	608	build_tabs($template, $record, $dbh, $input);
623	build_hidden_data;	609	build_hidden_data;
624	$template->param(authid =>$authid,	610	$template->param(authid =>$authid,
625	duplicateauthid => $duplicateauthid,	611	duplicateauthid => $duplicateauthid,
Lines 640-646 if ($op eq "duplicate") Link Here
640	{	626	{
641	$authid = "";	627	$authid = "";
642	}	628	}
643	build_tabs ($template, $record, $dbh,$encoding,$input);	629	build_tabs ($template, $record, $dbh, $input);
644	build_hidden_data;	630	build_hidden_data;
645	$template->param(oldauthtypetagfield=>$oldauthtypetagfield, oldauthtypetagsubfield=>$oldauthtypetagsubfield,	631	$template->param(oldauthtypetagfield=>$oldauthtypetagfield, oldauthtypetagsubfield=>$oldauthtypetagsubfield,
646	oldauthnumtagfield=>$oldauthnumtagfield, oldauthnumtagsubfield=>$oldauthnumtagsubfield,	632	oldauthnumtagfield=>$oldauthnumtagfield, oldauthnumtagsubfield=>$oldauthnumtagsubfield,

Lines 10-15 use t::lib::Mocks; Link Here

(-)a/t/db_dependent/ImportBatch.t (-39 / +97 lines)
10	use t::lib::TestBuilder;	10	use t::lib::TestBuilder;
11		11
12	use Koha::Database;	12	use Koha::Database;
		13	use Koha::Import::Records;
13		14
14	BEGIN {	15	BEGIN {
15	# Mock pluginsdir before loading Plugins module	16	# Mock pluginsdir before loading Plugins module
Lines 17-23 BEGIN { Link Here
17	t::lib::Mocks::mock_config( 'pluginsdir', $path );	18	t::lib::Mocks::mock_config( 'pluginsdir', $path );
18		19
19	use_ok('Koha::Plugins');	20	use_ok('Koha::Plugins');
20	use_ok('C4::ImportBatch', qw( AddImportBatch GetImportBatch AddBiblioToBatch AddItemsToImportBiblio GetRecordFromImportBiblio SetMatchedBiblionumber GetImportBiblios GetItemNumbersFromImportBatch CleanBatch DeleteBatch RecordsFromMarcPlugin ));	21	use_ok('C4::ImportBatch', qw( AddImportBatch GetImportBatch AddBiblioToBatch AddItemsToImportBiblio SetMatchedBiblionumber GetImportBiblios GetItemNumbersFromImportBatch CleanBatch DeleteBatch RecordsFromMarcPlugin ));
21	}	22	}
22		23
23	# Start transaction	24	# Start transaction
Lines 93-139 my $original_record = MARC::Record->new; Link Here
93	$record->leader('03174nam a2200445 a 4500');	94	$record->leader('03174nam a2200445 a 4500');
94	$original_record->leader('03174nam a2200445 a 4500');	95	$original_record->leader('03174nam a2200445 a 4500');
95	my ($item_tag, $item_subfield) = C4::Biblio::GetMarcFromKohaField( 'items.itemnumber' );	96	my ($item_tag, $item_subfield) = C4::Biblio::GetMarcFromKohaField( 'items.itemnumber' );
96	my @fields = (	97	my @fields;
97	MARC::Field->new(	98	if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
98	100, '1', ' ',	99	@fields = (
99	a => 'Knuth, Donald Ervin',	100	MARC::Field->new(
100	d => '1938',	101	100, ' ', ' ',
101	),	102	a => '20220520d u\|\|y0frey50 ba',
102	MARC::Field->new(	103	),
103	245, '1', '4',	104	MARC::Field->new(
104	a => 'The art of computer programming',	105	700, ' ', ' ',
105	c => 'Donald E. Knuth.',	106	a => 'Knuth, Donald Ervin',
106	),	107	f => '1938',
107	MARC::Field->new(	108	),
108	650, ' ', '0',	109	MARC::Field->new(
109	a => 'Computer programming.',	110	200, ' ', ' ',
110	9 => '462',	111	a => 'The art of computer programming',
111	),	112	f => 'Donald E. Knuth.',
112	MARC::Field->new(	113	),
113	$item_tag, ' ', ' ',	114	MARC::Field->new(
114	e => 'my edition ❤',	115	650, ' ', '0',
115	i => 'my item part',	116	a => 'Computer programming.',
116	),	117	9 => '462',
117	MARC::Field->new(	118	),
118	$item_tag, ' ', ' ',	119	MARC::Field->new(
119	e => 'my edition 2',	120	$item_tag, ' ', ' ',
120	i => 'my item part 2',	121	e => 'my edition ❤',
121	),	122	i => 'my item part',
122	);	123	),
		124	MARC::Field->new(
		125	$item_tag, ' ', ' ',
		126	e => 'my edition 2',
		127	i => 'my item part 2',
		128	),
		129	);
		130	} else {
		131	@fields = (
		132	MARC::Field->new(
		133	100, '1', ' ',
		134	a => 'Knuth, Donald Ervin',
		135	d => '1938',
		136	),
		137	MARC::Field->new(
		138	245, '1', '4',
		139	a => 'The art of computer programming',
		140	c => 'Donald E. Knuth.',
		141	),
		142	MARC::Field->new(
		143	650, ' ', '0',
		144	a => 'Computer programming.',
		145	9 => '462',
		146	),
		147	MARC::Field->new(
		148	$item_tag, ' ', ' ',
		149	e => 'my edition ❤',
		150	i => 'my item part',
		151	),
		152	MARC::Field->new(
		153	$item_tag, ' ', ' ',
		154	e => 'my edition 2',
		155	i => 'my item part 2',
		156	),
		157	);
		158	}
123	$record->append_fields(@fields);	159	$record->append_fields(@fields);
124	$original_record->append_fields(@fields);	160	$original_record->append_fields(@fields);
125	my $import_record_id = AddBiblioToBatch( $id_import_batch1, 0, $record, 'utf8', int(rand(99999)), 0 );	161	my $import_record_id = AddBiblioToBatch( $id_import_batch1, 0, $record, 'utf8', int(rand(99999)), 0 );
126	AddItemsToImportBiblio( $id_import_batch1, $import_record_id, $record, 0 );	162	AddItemsToImportBiblio( $id_import_batch1, $import_record_id, $record, 0 );
127		163
128	my $record_from_import_biblio_with_items = C4::ImportBatch::GetRecordFromImportBiblio( $import_record_id, 'embed_items' );	164	my $import_record = Koha::Import::Records->find($import_record_id);
		165	my $record_from_import_biblio_with_items = $import_record->get_marc_record({ embed_items => 1 });
129	$original_record->leader($record_from_import_biblio_with_items->leader());	166	$original_record->leader($record_from_import_biblio_with_items->leader());
130	is_deeply( $record_from_import_biblio_with_items, $original_record, 'GetRecordFromImportBiblio should return the record with items if specified' );	167	is_deeply( $record_from_import_biblio_with_items, $original_record, 'Koha::Import::Record::get_marc_record should return the record with items if specified' );
131	my $utf8_field = $record_from_import_biblio_with_items->subfield($item_tag, 'e');	168	my $utf8_field = $record_from_import_biblio_with_items->subfield($item_tag, 'e');
132	is($utf8_field, 'my edition ❤');	169	is($utf8_field, 'my edition ❤');
133	$original_record->delete_fields($original_record->field($item_tag)); #Remove items fields	170	$original_record->delete_fields($original_record->field($item_tag)); #Remove items fields
134	my $record_from_import_biblio_without_items = C4::ImportBatch::GetRecordFromImportBiblio( $import_record_id );	171	my $record_from_import_biblio_without_items = $import_record->get_marc_record();
135	$original_record->leader($record_from_import_biblio_without_items->leader());	172	$original_record->leader($record_from_import_biblio_without_items->leader());
136	is_deeply( $record_from_import_biblio_without_items, $original_record, 'GetRecordFromImportBiblio should return the record without items by default' );	173	is_deeply( $record_from_import_biblio_without_items, $original_record, 'Koha::Import::Record::get_marc_record should return the record without items by default' );
137		174
138	my $another_biblio = $builder->build_sample_biblio;	175	my $another_biblio = $builder->build_sample_biblio;
139	C4::ImportBatch::SetMatchedBiblionumber( $import_record_id, $another_biblio->biblionumber );	176	C4::ImportBatch::SetMatchedBiblionumber( $import_record_id, $another_biblio->biblionumber );
Lines 175-181 my $id_import_batch3 = C4::ImportBatch::AddImportBatch($sample_import_batch3); Link Here
175		212
176	# Test CleanBatch	213	# Test CleanBatch
177	C4::ImportBatch::CleanBatch( $id_import_batch3 );	214	C4::ImportBatch::CleanBatch( $id_import_batch3 );
178	my $import_record = get_import_record( $id_import_batch3 );	215	$import_record = get_import_record( $id_import_batch3 );
179	is( $import_record, "0E0", "Batch 3 has been cleaned" );	216	is( $import_record, "0E0", "Batch 3 has been cleaned" );
180		217
181	# Test DeleteBatch	218	# Test DeleteBatch
Lines 188-194 subtest "RecordsFromMarcPlugin" => sub { Link Here
188		225
189	# Create a test file	226	# Create a test file
190	my ( $fh, $name ) = tempfile();	227	my ( $fh, $name ) = tempfile();
191	print $fh q\|	228	if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
		229	print $fh q{
		230	003 = NLAmRIJ
		231	100,a = 20220520d u\|\|y0frey50 ba
		232	700,a = Author
		233	200,ind2 = 0
		234	200,a = Silence in the library
		235	500 , a= Some note
		236
		237	700,a = Another
		238	245,a = Noise in the library};
		239	close $fh;
		240	} else {
		241	print $fh q\|
192	003 = NLAmRIJ	242	003 = NLAmRIJ
193	100,a = Author	243	100,a = Author
194	245,ind2 = 0	244	245,ind2 = 0
Lines 197-203 subtest "RecordsFromMarcPlugin" => sub { Link Here
197		247
198	100,a = Another	248	100,a = Another
199	245,a = Noise in the library\|;	249	245,a = Noise in the library\|;
200	close $fh;	250	close $fh;
		251	}
201		252
202	t::lib::Mocks::mock_config( 'enable_plugins', 1 );	253	t::lib::Mocks::mock_config( 'enable_plugins', 1 );
203		254
Lines 208-217 subtest "RecordsFromMarcPlugin" => sub { Link Here
208	my $records = C4::ImportBatch::RecordsFromMarcPlugin( $name, ref $plugin, 'UTF-8' );	259	my $records = C4::ImportBatch::RecordsFromMarcPlugin( $name, ref $plugin, 'UTF-8' );
209	is( @$records, 2, 'Two results returned' );	260	is( @$records, 2, 'Two results returned' );
210	is( ref $records->[0], 'MARC::Record', 'Returned MARC::Record object' );	261	is( ref $records->[0], 'MARC::Record', 'Returned MARC::Record object' );
211	is( $records->[0]->subfield('245', 'a'), 'Silence in the library',	262	if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
212	'Checked one field in first record' );	263	is( $records->[0]->subfield('200', 'a'), 'Silence in the library',
213	is( $records->[1]->subfield('100', 'a'), 'Another',	264	'Checked one field in first record' );
214	'Checked one field in second record' );	265	is( $records->[1]->subfield('700', 'a'), 'Another',
		266	'Checked one field in second record' );
		267	} else {
		268	is( $records->[0]->subfield('245', 'a'), 'Silence in the library',
		269	'Checked one field in first record' );
		270	is( $records->[1]->subfield('100', 'a'), 'Another',
		271	'Checked one field in second record' );
		272	}
215	};	273	};
216		274
217	subtest "_get_commit_action" => sub {	275	subtest "_get_commit_action" => sub {

Lines 30-39 use C4::Output qw( output_html_with_http_headers ); Link Here

(-)a/tools/showdiffmarc.pl (-3 / +4 lines)
30	use C4::Auth qw( get_template_and_user );	30	use C4::Auth qw( get_template_and_user );
31	use C4::Biblio qw( GetMarcBiblio );	31	use C4::Biblio qw( GetMarcBiblio );
32	use C4::Auth qw( get_template_and_user );	32	use C4::Auth qw( get_template_and_user );
33	use C4::ImportBatch qw( GetRecordFromImportBiblio GetImportBiblios );	33	use C4::ImportBatch qw( GetImportBiblios );
34	use C4::AuthoritiesMarc qw( GetAuthority );	34	use C4::AuthoritiesMarc qw( GetAuthority );
35		35
36	use Koha::Biblios;	36	use Koha::Biblios;
		37	use Koha::Import::Records;
37		38
38	# Input params	39	# Input params
39	my $input = CGI->new;	40	my $input = CGI->new;
Lines 79-85 if( $record ) { Link Here
79	}	80	}
80		81
81	if( $importid ) {	82	if( $importid ) {
82	$recordImportid = C4::ImportBatch::GetRecordFromImportBiblio( $importid, 'embed_items' );	83	my $import_record = Koha::Import::Records->find($importid);
		84	my $recordImportid = $import_record->get_marc_record({ embed_items => 1 });
83	$formatted2 = $recordImportid->as_formatted;	85	$formatted2 = $recordImportid->as_formatted;
84	my $biblio = GetImportBiblios($importid);	86	my $biblio = GetImportBiblios($importid);
85	$importTitle = $biblio->[0]->{'title'};	87	$importTitle = $biblio->[0]->{'title'};
86	-