File Coverage

blib/lib/Buzznet/API.pm

Criterion	Covered	Total	%
statement	114	384	29.6
branch	0	44	0.0
condition			n/a
subroutine	38	74	51.3
pod			n/a
total	152	502	30.2

package Buzznet::API;

use strict; use warnings;

require Exporter;
use AutoLoader qw(AUTOLOAD);

our @ISA = qw(Exporter);

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

# This allows declaration	use Buzznet::API ':all';
# If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
# will save memory.
our %EXPORT_TAGS = ( 'all' => [ qw(

) ] );

our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );

our @EXPORT = qw(

);

our $VERSION = '0.01';

#require XSLoader;
#XSLoader::load('Buzznet::API', $VERSION);

# Preloaded methods go here.
require RPC::XML;
require RPC::XML::Client;
require MIME::Base64;
use Buzznet::Entry;
use Buzznet::Comment;
use Buzznet::Profile;
use Buzznet::Gallery;


# Method constants
use constant NEWPOST 		=> "buzznet.newPost";
use constant EDITPOST 		=> "buzznet.editPost";
use constant REMOVEPOST 	=> "buzznet.removePost";
use constant GETENTRY 		=> "buzznet.getEntry";
use constant GETCOMMENTS 	=> "buzznet.getComments";
use constant ADDCOMMENT 	=> "buzznet.addComment";
use constant REMOVECOMMENT	=> "buzznet.removeComment";
use constant GETRECENTCOMMENTS 	=> "buzznet.getRecentComments";
use constant ADDBUZZWORDS 	=> "buzznet.addBuzzwords";
use constant REMOVEBUZZWORDS 	=> "buzznet.removeBuzzwords";
use constant UPDATEPROFILE	=> "buzznet.updateProfile";
use constant ADDFRIEND 		=> "buzznet.addFriend";
use constant REMOVEFRIEND 	=> "buzznet.removeFriend";
use constant ADDGALLERY 	=> "buzznet.addGallery";
use constant EDITGALLERY 	=> "buzznet.editGallery";
use constant REMOVEGALLERY 	=> "buzznet.removeGallery";
use constant ADDBOOKMARK 	=> "buzznet.addBookmark";
use constant REMOVEBOOKMARK 	=> "buzznet.removeBookmark";
use constant GETBOOKMARKS 	=> "buzznet.getBookmarks";
use constant GETMYFRIENDS 	=> "buzznet.getMyFriends";
use constant GETFRIENDS 	=> "buzznet.getFriends";
use constant GETFRIENDSRECENT 	=> "buzznet.getFriendsRecent";
use constant GETMOSTPOPULAR 	=> "buzznet.getMostPopular";
use constant GETTODAYSBIRTHDAYS => "buzznet.getTodaysBirthdays";
use constant GETONLINENOW 	=> "buzznet.getOnlineNow";
use constant GETRECENTPOSTS 	=> "buzznet.getRecentPosts";
use constant GETFEATUREDUSERS 	=> "buzznet.getFeaturedUsers";
use constant GETBUZZWORD 	=> "buzznet.getBuzzwords";
use constant BROWSEBUZZWORDS 	=> "buzznet.browseBuzzwords";
use constant GETGALLERY 	=> "buzznet.getGallery";
use constant GETSUBGALLERIES 	=> "buzznet.getSubGalleries";

sub new
{
  my ($package,@refs) = @_;
  my $inst = {@refs};
  $inst->{"error"} = undef;
  return bless($inst,$package);
}

sub url
{
  my $self = shift;
  my $url = "http://www.buzznet.com/interface/xmlrpc/?key=" . $self->{"key"};
  return $url;
}

sub getXMLRPC
{
  my $self = shift;
  my $cli = RPC::XML::Client->new($self->url);
  $cli->credentials("Buzznet",$self->{"username"},$self->{"password"});
  my $request = $cli->request;
  return $cli;
}

sub sendRequest
{
  my $self = shift;

  my $request = RPC::XML::request->new(@_);

  my $client = $self->getXMLRPC;

  my $response = $client->send_request($request);

  if(ref($response))
  {
    if(!$response->value)
    {
      $self->{"error"} = "Error response from server";
    }
    return $response->value;
  }
  else
  {
    $self->{"error"} = $response;

    # error condition
    return 0;
  }
}

sub error
{
  my $self = shift;
  return $self->{"error"};
}

sub newPost
{
  my $self = shift;
  my ($filename, $caption, $body, $category) = @_;

  my $encoded_file = "";

  eval
  {
    open(FILE,$filename) || die "Could not open $filename: $!\n";
    while(read(FILE,my $buf,60*57))
    {
      $encoded_file .= MIME::Base64::encode_base64($buf);
    }

  };

  if($@)
  {
    $self->{"error"} = $@;

    # error condition
    return 0;
  }

  return $self->sendRequest(NEWPOST,
                            RPC::XML::string->new($encoded_file),
                            RPC::XML::string->new($caption),
                            RPC::XML::string->new($body),
                            RPC::XML::string->new($category));

}

sub editPost
{
  my $self = shift;
  my ($entryId, $filename, $caption, $body, $category) = @_;

  my $encoded_file = "";

  eval
  {
    open(FILE,$filename) || die "Could not open $filename: $!\n";
    while(read(FILE,my $buf,60*57))
    {
      $encoded_file .= MIME::Base64::encode_base64($buf);
    }

  };

  if($@)
  {
    $self->{"error"} = $@;

    # error condition
    return 0;
  }

  return $self->sendRequest(EDITPOST,
                            RPC::XML::string->new($entryId),
                            RPC::XML::string->new($encoded_file),
                            RPC::XML::string->new($caption),
                            RPC::XML::string->new($body));
}

sub removePost
{
  my $self = shift;
  my $entryId = shift;

  return $self->sendRequest(REMOVEPOST,RPC::XML::string->new($entryId));
}

sub getEntry
{
  my $self = shift;
  my ($entryId, $type) = @_;

  print "ENTRY: $entryId\n";
  print "TYPE: $type\n";
  my $rawentry = $self->sendRequest(GETENTRY,
                                    RPC::XML::string->new($entryId),
                                    RPC::XML::string->new($type));

  if($rawentry)
  {
    return Buzznet::Entry->new(%{$rawentry});
  }
  else
  {
    return $rawentry;
  }
}

sub addGallery
{
  my $self = shift;
  my ($name, $title, $description, $keyword, $password) = @_;

  return $self->sendRequest(ADDGALLERY,
			    RPC::XML::string->new($name),
			    RPC::XML::string->new($title),
			    RPC::XML::string->new($description),
			    RPC::XML::string->new($keyword),
			    RPC::XML::string->new($password));
}

sub editGallery
{
  my $self = shift;
  my ($name, $title, $description, $keyword, $password) = @_;

  return $self->sendRequest(EDITGALLERY,
			    RPC::XML::string->new($name),
			    RPC::XML::string->new($title),
			    RPC::XML::string->new($description),
			    RPC::XML::string->new($keyword),
			    RPC::XML::string->new($password));
}

sub removeGallery
{
  my $self = shift;
  my $name = shift;

  return $self->sendRequest(REMOVEGALLERY,RPC::XML::string->new($name));
}

sub getSubGalleries
{
  my $self = shift;
  my $username = shift;

  my $rawgalleries = $self->sendRequest(GETSUBGALLERIES,
                                        RPC::XML::string->new($username));

  my @galleries = ();
  if($rawgalleries)
  {
    foreach my $gallery (@{$rawgalleries})
    {
      my %hash = %{$gallery};
      my $buzznetGallery = Buzznet::Gallery->new(%hash);
      push(@galleries,$buzznetGallery);
    }
  }

  return @galleries;
}

sub getGallery
{
  my $self = shift;
  my ($blogname, $mode, $user_cat, $current_page, $pagesize) = @_;

  my $rawentries = $self->sendRequest(GETGALLERY,
                                      RPC::XML::string->new($blogname),
                                      RPC::XML::string->new($mode),
                                      RPC::XML::string->new($user_cat),
                                      RPC::XML::int->new($current_page),
                                      RPC::XML::int->new($pagesize));


  my @entries = ();
  if($rawentries)
  {
    foreach my $entry (@{$rawentries})
    {
      my %hash = %{$entry};
      my $buzznetEntry = Buzznet::Entry->new(%hash);
      push(@entries,$buzznetEntry);
    }
  }

  return @entries;

}

sub getRecentPosts
{
  my $self = shift;
  my $type = shift;

  my $rawentries = $self->sendRequest(GETRECENTPOSTS,
                                      RPC::XML::string->new($type));


  my @entries = ();
  if($rawentries)
  {
    foreach my $entry (@{$rawentries})
    {
      my %hash = %{$entry};
      my $buzznetEntry = Buzznet::Entry->new(%hash);
      push(@entries,$buzznetEntry);
    }
  }

  return @entries;
}

sub getComments
{
  my $self = shift;
  my ($entryId, $type) = @_;

  my $rawcomments = $self->sendRequest(GETCOMMENTS,
                                       RPC::XML::string->new($entryId),
                                       RPC::XML::string->new($type));


  my @comments = ();
  if($rawcomments)
  {
    foreach my $comment (@{$rawcomments})
    {
      my %hash = %{$comment};
      my $buzznetComment = Buzznet::Comment->new(%hash);
      push(@comments,$buzznetComment);
    }
  }

  return @comments;

}

sub addComment
{
  my $self = shift;
  my ($entryId, $comment, $type) = @_;

  return $self->sendRequest(ADDCOMMENT,
			    RPC::XML::string->new($entryId),
			    RPC::XML::string->new($comment),
			    RPC::XML::string->new($type));
}

sub removeComment
{
  my $self = shift;
  my $commentId = shift;

  return $self->sendRequest(REMOVECOMMENT,
                            RPC::XML::string->new($commentId));

}

sub getRecentComments
{
  my $self = shift;
  my $username = shift;

  my $rawcomments = $self->sendRequest(GETRECENTCOMMENTS,
                                       RPC::XML::string->new($username));


  my @comments = ();
  if($rawcomments)
  {
    foreach my $comment (@{$rawcomments})
    {
      my %hash = %{$comment};
      my $buzznetComment = Buzznet::Comment->new(%hash);
      push(@comments,$buzznetComment);
    }
  }

  return @comments;
}

sub addBuzzwords
{
  my $self = shift;
  my ($entryId, $buzzwords, $type) = @_;

  return $self->sendRequest(ADDBUZZWORDS,
			    RPC::XML::string->new($entryId),
			    RPC::XML::string->new($buzzwords),
			    RPC::XML::string->new($type));
}

sub removeBuzzwords
{
  my $self = shift;
  my ($entryId, $buzzword) = @_;

  return $self->sendRequest(REMOVEBUZZWORDS,
			    RPC::XML::string->new($entryId),
			    RPC::XML::string->new($buzzword));
}

sub getBuzzword
{
  my $self = shift;
  my ($buzzword, $pagesize, $pageNumber) = @_;

  my $rawentries = $self->sendRequest(GETBUZZWORD,
                                      RPC::XML::string->new($buzzword),
                                      RPC::XML::int->new($pagesize),
                                      RPC::XML::int->new($pageNumber));


  my @entries = ();
  if($rawentries)
  {
    foreach my $entry (@{$rawentries})
    {
      my %hash = %{$entry};
      my $buzznetEntry = Buzznet::Entry->new(%hash);
      push(@entries,$buzznetEntry);
    }
  }

  return @entries;


}

sub browseBuzzwords
{
  my $self = shift;
  my $numberBuzzwords = shift;

  my $rawbuzzwords = $self->sendRequest(BROWSEBUZZWORDS,
                                        RPC::XML::int->new($numberBuzzwords));


  my @buzzwords = ();
  if($rawbuzzwords)
  {
    foreach my $buzzword (@{$rawbuzzwords})
    {
      my %hash = %{$buzzword};
      my $buzznetBuzzword = Buzznet::Buzzword->new(%hash);
      push(@buzzwords,$buzznetBuzzword);
    }
  }

  return @buzzwords;
}

sub updateProfile
{
  my $self = shift;
  my $profile = shift;

  return $self->sendRequest(UPDATEPROFILE,
                            RPC::XML::string->new($profile->password),
                            RPC::XML::string->new($profile->keyword),
                            RPC::XML::string->new($profile->fname),
                            RPC::XML::string->new($profile->lname),
                            RPC::XML::string->new($profile->email),
                            RPC::XML::string->new($profile->address),
                            RPC::XML::string->new($profile->city),
                            RPC::XML::string->new($profile->state),
                            RPC::XML::string->new($profile->zip),
                            RPC::XML::string->new($profile->country),
                            RPC::XML::string->new($profile->dob),
                            RPC::XML::string->new($profile->gender),
                            RPC::XML::string->new($profile->status));
}

sub addFriend
{
  my $self = shift;
  my ($username, $order) = @_;


  return $self->sendRequest(ADDFRIEND,
                            RPC::XML::string->new($username),
                            RPC::XML::int->new($order));

}

sub removeFriend
{
  my $self = shift;
  my $username = shift;

  return $self->sendRequest(REMOVEFRIEND, RPC::XML::string->new($username));
}

sub getMyFriends
{
  my $self = shift;

  my $rawfriends = $self->sendRequest(GETMYFRIENDS);

  my @friends = ();
  if($rawfriends)
  {
    foreach my $friend (@{$rawfriends})
    {
      my %hash = %{$friend};
      my $buzznetFriend = Buzznet::Profile->new(%hash);
      push(@friends,$buzznetFriend);
    }
  }

  return @friends;
}

sub getFriends
{
  my $self = shift;
  my $userId = shift;

  my $rawfriends = $self->sendRequest(GETFRIENDS, RPC::XML::int->new($userId));

  my @friends = ();
  if($rawfriends)
  {
    foreach my $friend (@{$rawfriends})
    {
      my %hash = %{$friend};
      my $buzznetFriend = Buzznet::Profile->new(%hash);
      push(@friends,$buzznetFriend);
    }
  }

  return @friends;

}

sub getFriendsRecent
{
  my $self = shift;
  my $userId = shift;

  my $rawentries = $self->sendRequest(GETFRIENDSRECENT,
                                      RPC::XML::int->new($userId));


  my @entries = ();
  if($rawentries)
  {
    foreach my $entry (@{$rawentries})
    {
      my %hash = %{$entry};
      my $buzznetEntry = Buzznet::Entry->new(%hash);
      push(@entries,$buzznetEntry);
    }
  }

  return @entries;
}

sub addBookmark
{
  my $self = shift;
  my ($entryId, $type, $order) = @_;

  return $self->sendRequest(ADDBOOKMARK,
                            RPC::XML::string->new($entryId),
                            RPC::XML::string->new($type),
                            RPC::XML::string->new($order));

}

sub removeBookmark
{
  my $self = shift;
  my ($entryId, $type) = @_;

  return $self->sendRequest(REMOVEBOOKMARK,
                            RPC::XML::string->new($entryId),
                            RPC::XML::string->new($type));
}

sub getBookmarks
{
  my $self = shift;

  my $rawentries = $self->sendRequest(GETBOOKMARKS);


  my @entries = ();
  if($rawentries)
  {
    foreach my $entry (@{$rawentries})
    {
      my %hash = %{$entry};
      my $buzznetEntry = Buzznet::Entry->new(%hash);
      push(@entries,$buzznetEntry);
    }
  }

  return @entries;
}

sub getMostPopular
{
  my $self = shift;
  my $type = shift;

  my $rawentries = $self->sendRequest(GETMOSTPOPULAR,
                                      RPC::XML::string->new($type));

  my @entries = ();
  if($rawentries)
  {
    foreach my $entry (@{$rawentries})
    {
      my %hash = %{$entry};
      my $buzznetEntry = Buzznet::Entry->new(%hash);
      push(@entries,$buzznetEntry);
    }
  }

  return @entries;
}

sub getTodaysBirthdays
{
  my $self = shift;

  my $rawbirthdays = $self->sendRequest(GETTODAYSBIRTHDAYS);

  my @birthdays = ();
  if($rawbirthdays)
  {
    foreach my $birthday (@{$rawbirthdays})
    {
      my %hash = %{$birthday};
      my $buzznetBirthday = Buzznet::Profile->new(%hash);
      push(@birthdays,$buzznetBirthday);
    }
  }

  return @birthdays;
}

sub getOnlineNow
{
  my $self = shift;
  my $rawonline = $self->sendRequest(GETONLINENOW);

  my @onlines = ();
  if($rawonline)
  {
    foreach my $online (@{$rawonline})
    {
      my %hash = %{$online};
      my $buzznetOnline = Buzznet::Profile->new(%hash);
      push(@onlines,$buzznetOnline);
    }
  }

  return @onlines;
}

sub getFeaturedUsers
{
  my $self = shift;
  my $numberUsers = shift;

  my $rawfeatured = $self->sendRequest(GETFEATUREDUSERS,
                                       RPC::XML::int->new($numberUsers));

  my @featureds = ();
  if($rawfeatured)
  {
    foreach my $featured (@{$rawfeatured})
    {
      my %hash = %{$featured};
      my $buzznetFeatured = Buzznet::Profile->new(%hash);
      push(@featureds,$buzznetFeatured);
    }
  }

  return @featureds;
}

# Autoload methods go after =cut, and are processed by the autosplit program.

1;
__END__