File Coverage

blib/lib/Footprintless/Plugin/Atlassian/Confluence/Client.pm

Criterion	Covered	Total	%
statement	42	66	63.6
branch	8	18	44.4
condition	5	15	33.3
subroutine	9	10	90.0
pod	2	2	100.0
total	66	111	59.4

use strict;
use warnings;

package Footprintless::Plugin::Atlassian::Confluence::Client;
$Footprintless::Plugin::Atlassian::Confluence::Client::VERSION = '1.02';
# ABSTRACT: A REST client for Atlassian Confluence
# PODNAME: Footprintless::Plugin::Atlassian::Confluence::Client

use parent qw(Footprintless::MixableBase);

use Footprintless::Mixins qw(
    _sub_entity
);
use Footprintless::Util qw(
    dynamic_module_new
);
use Log::Any;

my $logger = Log::Any->get_logger();

sub _init {
    my ( $self, %options ) = @_;

    $self->{username} = $self->_sub_entity( 'automation.username', 1 );
    $self->{password} = $self->_sub_entity( 'automation.password', 1 );
    $self->{agent} = $options{agent} || $self->{factory}->agent();
    $self->{request_builder} = dynamic_module_new(
        (   $options{request_builder_module}
                || 'Footprintless::Plugin::Atlassian::Confluence::RequestBuilder'
        ),
        $self->_web_url()
    );
    $self->{response_parser} = dynamic_module_new(
        (   $options{response_parser_module}
                || 'Footprintless::Plugin::Atlassian::Confluence::ResponseParser'
        )
    );

    return $self;
}

sub request {
    my ( $self, $endpoint, $args, %response_options ) = @_;

    my $response;
    eval {
        $logger->debugf( 'requesting %s', $endpoint );
        my $http_request = $self->{request_builder}->$endpoint( ( $args ? @$args : () ) );
        $http_request->authorization_basic( $self->{username}, $self->{password} );

        if ( $logger->is_trace() ) {
            $logger->trace(
                join( '',
                    "----------------------BEGIN REQUEST--------------------\n",
                    $http_request->dump( maxlength => 500 ),
                    "\n---------------------- END REQUEST --------------------\n" )
            );
        }

        my @content = ();
        if ( $response_options{content_file} ) {
            $logger->tracef( 'writing response to %s', $response_options{content_file} );
            push( @content, $response_options{content_file} );
        }
        elsif ( $response_options{content_cb} ) {
            $logger->trace('writing response to callback');
            push( @content, $response_options{content_cb}, $response_options{read_size_hint} );
        }

        my $http_response = $self->{agent}->request( $http_request, @content );

        if ( $logger->is_trace() ) {
            $logger->trace(
                join( '',
                    "----------------------BEGIN RESPONSE--------------------\n",
                    $http_response->dump( maxlength => 500 ),
                    "\n---------------------- END RESPONSE --------------------\n" )
            );
        }

        $response = $self->{response_parser}->$endpoint( $http_response, %response_options );
    };
    if ($@) {
        if ( ref($@) eq 'HASH' && $@->{code} ) {
            $response = $@;
        }
        else {
            $response = {
                code    => 500,
                content => {},
                message => $@,
                success => 0,
            };
        }
    }
    return $response;
}

sub request_all {
    my ( $self, $endpoint, $args, @response_options ) = @_;

    my $response = $self->request(
        $endpoint,
        [   @$args,
            limit => 100,
            start => 0
        ],
        @response_options
    );

    my $next = $response;
    while ( $next->{success} && $next->{content}{_links}{next} ) {
        my $limit = $response->{content}{limit};
        $next = $self->request(
            $endpoint,
            [   @$args,
                limit => $limit,
                start => $next->{content}{start} + $limit,
            ],
            @response_options
        );
        push( @{ $response->{content}{results} }, @{ $next->{content}{results} } );
    }

    delete( $response->{content}{_links}{next} );
    $response->{content}{limit} = scalar( @{ $response->{content}{results} } );
    $response->{content}{size}  = $response->{content}{limit};
    $response->{content}{start} = 0;

    return $response;
}

sub _web_url {
    my ($self) = @_;
    my $web = $self->_sub_entity( 'web', 1 );

    return
          ( $web->{https} ? 'https://' : 'http://' )
        . $web->{hostname}
        . ( $web->{port} ? ":$web->{port}" : '' )
        . ( $web->{context_path} || '' );
}

1;

__END__