File Coverage

blib/lib/Net/SMS/ViaNett.pm

Criterion	Covered	Total	%
statement	16	18	88.8
branch			n/a
condition			n/a
subroutine	6	6	100.0
pod			n/a
total	22	24	91.6

package Net::SMS::ViaNett;

=head1 NAME

Net::SMS::ViaNett  -  Perl Interface to Vianett HTTP API

=cut

use strict;
use warnings;
use Carp;
use Scalar::Util qw/blessed reftype/;
use LWP::UserAgent;
use XML::Simple;
use Data::URIEncode;

use constant VIANETT_URL => 'http://smsc.vianett.no/ActiveServer/MT/';

our $VERSION = q(0.02);

sub _validate {
  shift;

  my $args      = shift;
  my $transform = { };

  my $allowed = {
    to => {
      translate   => 'destinationaddr',
      required    => 1,
      default     => undef,
    },

    from => {
      translate   => 'sourceaddr',
      required    => 1,
      default     => sub { int( rand( 9999 ) ) }
    },

    msg => {
      translate   => 'message',
      required    => 1,
      default     => undef
    },

    refno => {
      translate   => 'refno',
      required    => 1,
      default     => sub { int( rand( 999999 ) ) }
    },

    origin => {
      translate   => 'fromalpha',
      required    => 0,
      default     => undef
    },

    header => {
      translate   => 'messageheader',
      required    => 0,
      default     => undef
    },

    operator => {
      translate   => 'operator',
      required    => 0,
      default     => 0
    },

    pricegroup => {
      translate   => 'pricegroup',
      required    => 0,
      default     => 0
    }
  };

  foreach my $k ( keys %$allowed ) {

    __PACKAGE__->_error( "$k is a required parameter" )
      if(
        $allowed->{$k}->{required}             &&     # A Required Key
        ! defined( $allowed->{$k}->{default} ) &&     # With no defaults Given
        ! exists( $args->{$k} )                       # Must Exist in the parameters
      );


      if( exists( $args->{$k} ) && defined( $args->{$k} ) ) {
        $transform->{ $allowed->{$k}->{translate} }  = $args->{$k};
      } elsif( $allowed->{$k}->{required} && ! exists( $args->{$k} ) ) {
        if( reftype $allowed->{$k}->{default} eq 'CODE' ) {
          $transform->{ $allowed->{$k}->{translate} } = &{$allowed->{$k}->{default}}();
        } else {
          $transform->{ $allowed->{$k}->{translate} } = $allowed->{$k}->{default};
        }
      }
  }

  return $transform;
};



sub new {
  my $class = shift;
  my %args  = @_;

  __PACKAGE__->_error("Can't call from instantiated object") if blessed $class;
  __PACKAGE__->_error("Can't call as static method") unless( $class->isa( __PACKAGE__ ) );
  __PACKAGE__->_error("Invalid arguments passed to the constructor")
    unless( %args && ( defined $args{username} && defined $args{password} ) );

  my $this = { %args };

  return bless $this, $class;
}


sub agent {
  my ( $this, $agent ) = @_;

  __PACKAGE__->error( "Cant call as static method" ) unless blessed $this;

  return ( $this->{_agent} || __PACKAGE__ . '/' . $VERSION ) unless $agent;

  $this->{_agent} = $agent;
}


sub _to_url {
  my ( $this, $params ) = @_;

  __PACKAGE__->error( "Cant call as static method" ) unless blessed $this;

  # username and password
  @{$params}{qw/username password/} = ( $this->{username}, $this->{password} );

  return VIANETT_URL . '?' . Data::URIEncode::complex_to_query( $params )
}


sub send {
  my $this = shift;

  __PACKAGE__->_error( "Cant call as static method" ) unless blessed $this;

  my %args      = @_;
  my $response  = $this->_call( $this->_to_url( $this->_validate( { %args } ) ) );

  return $response->{errorcode} == 0 ? 1 : 0;
}



sub _call {
  my $this = shift;

  __PACKAGE__->_error( "Cant call as static method" ) unless blessed $this;

  my ( $url, $ua, $response ) = ( shift, LWP::UserAgent->new,  );
  $ua->agent( $this->agent );
  $response = $ua->get( $url );

  __PACKAGE__->_error( "Error Making the request, server responded with " . $response->status_line )
    if $response->is_error;

  return XML::Simple::XMLin( $response->content );

}


sub _error {
  shift;
  confess shift;
}



1;
__END__