=head3 record

    my $record = $authority->record()

Return the MARC::Record for this authority

=cut

sub record {

    my ( $self ) = @_;

    my $flavour =

      C4::Context->preference('marcflavour') eq 'UNIMARC'

      ? 'UNIMARCAUTH'

      : 'MARC21';

    return MARC::Record->new_from_xml( $self->marcxml, 'UTF-8', $flavour );

}

package Koha::REST::V1::Authorities;

# 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 Mojo::Base 'Mojolicious::Controller';

use Koha::Authorities;

use List::MoreUtils qw( any );

use MARC::Record::MiJ;

use Try::Tiny qw( catch try );

=head1 API

=head2 Methods

=head3 get

Controller function that handles retrieving a single authority object

=cut

sub get {

    my $c = shift->openapi->valid_input or return;

    my $authority = Koha::Authorities->find( { authid => $c->validation->param('authority_id') } );

    unless ( $authority ) {

        return $c->render(

            status  => 404,

            openapi => {

                error => "Object not found."

            }

        );

    }

    return try {

        if ( $c->req->headers->accept =~ m/application\/json/ ) {

            return $c->render(

                status => 200,

                json   => $authority->to_api

            );

        }

        else {

            my $record = $authority->record;

            $c->respond_to(

                marcxml => {

                    status => 200,

                    format => 'marcxml',

                    text   => $record->as_xml_record

                },

                mij => {

                    status => 200,

                    format => 'mij',

                    data   => $record->to_mij

                },

                marc => {

                    status => 200,

                    format => 'marc',

                    text   => $record->as_usmarc

                },

                txt => {

                    status => 200,

                    format => 'text/plain',

                    text   => $record->as_formatted

                },

                any => {

                    status  => 406,

                    openapi => [

                        "application/json",

                        "application/marcxml+xml",

                        "application/marc-in-json",

                        "application/marc",

                        "text/plain"

                    ]

                }

            );

        }

    }

    catch {

        $c->unhandled_exception($_);

    };

}

1;

---

"/authorities/{authority_id}":

  get:

    x-mojo-to: Authorities#get

    operationId: getAuthority

    tags:

      - authorities

    summary: Get authority

    parameters:

      - $ref: "../swagger.yaml#/parameters/authority_id_pp"

    produces:

      - application/json

      - application/marcxml+xml

      - application/marc-in-json

      - application/marc

      - text/plain

    responses:

      "200":

        description: An authority

      "401":

        description: Authentication required

        schema:

          $ref: "../swagger.yaml#/definitions/error"

      "403":

        description: Access forbidden

        schema:

          $ref: "../swagger.yaml#/definitions/error"

      "404":

        description: Authority not found

        schema:

          $ref: "../swagger.yaml#/definitions/error"

      "406":

        description: Not acceptable

        schema:

          type: array

          description: Accepted content-types

          items:

            type: string

      "500":

        description: |

          Internal server error. Possible `error_code` attribute values:

          * `internal_server_error`

        schema:

          $ref: "../swagger.yaml#/definitions/error"

      "503":

        description: Under maintenance

        schema:

          $ref: "../swagger.yaml#/definitions/error"

    x-koha-authorization:

      permissions:

        catalogue: "1"

  "/authorities/{authority_id}":

    $ref: paths/authorities.yaml#/~1authorities~1{authority_id}

  authority_id_pp:

    description: Authority identifier

    in: path

    name: authority_id

    required: true

    type: integer

subtest 'record tests' => sub {

    plan tests => 3;

    t::lib::Mocks::mock_preference( 'marcflavour', 'MARC21' );

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

    $record->add_fields(

        [

            '100', ' ', ' ',

            a => 'Lastname, Firstname',

            b => 'b',

            c => 'c',

            i => 'i'

        ],

        [

            '024', '', '',

            a => '0000-0002-1234-5678',

            2 => 'orcid',

            6 => 'https://orcid.org/0000-0002-1234-5678'

        ],

        [

            '024', '', '',

            a => '01234567890',

            2 => 'scopus',

            6 => 'https://www.scopus.com/authid/detail.uri?authorId=01234567890'

        ],

    );

    my $authid = C4::AuthoritiesMarc::AddAuthority($record, undef, 'PERSO_NAME');

    my $authority = Koha::Authorities->find($authid);

    my $authority_record = $authority->record;

    is ($authority_record->field('100')->subfield('a'), 'Lastname, Firstname');

    my @fields_024 = $authority_record->field('024');

    is ($fields_024[0]->subfield('a'), '0000-0002-1234-5678');

    is ($fields_024[1]->subfield('a'), '01234567890');

};