File Coverage

blib/lib/WWW/StatsMix.pm

Criterion	Covered	Total	%
statement	87	168	51.7
branch	36	88	40.9
condition	15	84	17.8
subroutine	20	25	80.0
pod	10	10	100.0
total	168	375	44.8

package WWW::StatsMix;

$WWW::StatsMix::VERSION = '0.06';

=head1 NAME

WWW::StatsMix - Interface to StatsMix API.

=head1 VERSION

Version 0.06

=cut

use 5.006;
use JSON;
use Data::Dumper;

use WWW::StatsMix::Stat;
use WWW::StatsMix::Metric;
use WWW::StatsMix::UserAgent;
use WWW::StatsMix::Params qw(validate);

use Moo;
use namespace::clean;
extends 'WWW::StatsMix::UserAgent';

has format      => (is => 'ro', default => sub { return 'json' });
has metrics_url => (is => 'ro', default => sub { return 'http://api.statsmix.com/api/v2/metrics' });
has stats_url   => (is => 'ro', default => sub { return 'http://api.statsmix.com/api/v2/stats'   });
has track_url   => (is => 'ro', default => sub { return 'http://api.statsmix.com/api/v2/track'   });

=head1 DESCRIPTION

StatsMix provides an API that can be used to create, retrieve, update, and delete
metrics and stats resources. The API is built using RESTful principles.

The current version is 2.0.

To get an API key, you can sign up for a free Developer account L.

If you go over the number of API requests available to your account, the API will
return a 403 Forbidden error and an explanation. The number of API  requests  and
profiles  you  can  create is based on the type of account you have. For example,
Standard plans are limited to 300,000 API requests per month.

=head1 SYNOPSIS

    Use Strict; use warnings;
    use WWW::StatsMix;

    my $API_KEY = "Your API Key";
    my $api     = WWW::StatsMix->new(api_key => $API_KEY);

    my $metric_1 = $api->create_metric({ name => "Testing - 1" });
    my $metric_2 = $api->create_metric({ name => "Testing - 2", include_in_email => 0 });
    $api->update_metric($metric_2->id, { name => "Testing - 3", include_in_email => 1 });

    my $metrics  = $api->get_metrics;
    my $only_2   = $api->get_metrics({ limit => 2 });

=head1 METHODS

=head2 create_metric(\%params)

It creates new metric and returns the object of type L.The
possible parameters for the method are as below:

   +------------------+---------------------------------------------------------+
   | Key              | Description                                             |
   +------------------+---------------------------------------------------------+
   | name             | The name of the metric. Metric names must be unique     |
   | (required)       | within a profile.                                       |
   |                  |                                                         |
   | profile_id       | The profile the metric belongs in.                      |
   | (optional)       |                                                         |
   |                  |                                                         |
   | sharing          | Sharing status for the metric. Either "public"          |
   | (optional)       | (unauthenticated users can view the metric at the       |
   |                  | specific URL) or "none" (default).                      |
   |                  |                                                         |
   | include_in_email | This specifies whether to include the metric in the     |
   | (optional)       | daily StatsMix email sent to users.                     |
   |                  |                                                         |
   | url              | Publicly accessible URL for the metric (only if sharing |
   | (optional)       | is set to "public").                                    |
   +------------------+---------------------------------------------------------+

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY = "Your_API_Key";
   my $api     = WWW::StatsMix->new(api_key => $API_KEY);
   my $metric  = $api->create_metric({ name => "Testing API - 2" });

   print "Id: ", $metric->id, "\n";

=cut

sub create_metric {
    my ($self, $params) = @_;

    my $data = [
        { key => 'name'             , required => 1 },
        { key => 'profile_id'       , required => 0 },
        { key => 'url'              , required => 0 },
        { key => 'sharing'          , required => 0 },
        { key => 'include_in_email' , required => 0 },
        { key => 'format'           , required => 0 },
    ];
    validate($data, $params);

    if (exists $params->{sharing}
        && defined $params->{sharing}
        && ($params->{sharing} =~ /\bpublic\b/i)) {
        die "ERROR: Missing key 'url' since 'sharing' is provided."
            unless (exists $params->{url});
    }
    if (exists $params->{url} && defined $params->{url}) {
        die "ERROR: Missing key 'sharing' since 'url' is provided."
            unless (exists $params->{sharing});
    }

    $params->{format} = $self->format
        unless (exists $params->{format} && defined $params->{format});

    my $response = $self->post($self->metrics_url, [ %$params ]);
    my $content  = from_json($response->content);

    return WWW::StatsMix::Metric->new($content->{metric});
}

=head2 update_metric($metric_id, \%params)

It updates the metric & returns the object of type L. This
requires mandatory param 'metric_id' and atleast one of the following key as  ref
to hash format data. Possible parameters are as below:

   +------------------+---------------------------------------------------------+
   | Key              | Description                                             |
   +------------------+---------------------------------------------------------+
   | name             | The name of the metric. Metric names must be unique     |
   |                  | within a profile.                                       |
   |                  |                                                         |
   | sharing          | Sharing status for the metric. Either "public"          |
   |                  | (unauthenticated users can view the metric at the       |
   |                  | specific URL) or "none" (default).                      |
   |                  |                                                         |
   | include_in_email | This specifies whether to include the metric in the     |
   |                  | daily StatsMix email sent to users.                     |
   |                  |                                                         |
   | url              | Publicly accessible URL for the metric (only if sharing |
   |                  | is set to "public").                                    |
   +------------------+---------------------------------------------------------+

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY   = "Your_API_Key";
   my $api       = WWW::StatsMix->new(api_key => $API_KEY);
   my $metric_id = ;
   my $metric    = $api->update_metric($metric_id, { name => "Testing API - new" });

   print "Name: ", $metric->name, "\n";

=cut

sub update_metric {
    my ($self, $id, $params) = @_;

    die "ERROR: Missing the required metric id."  unless defined $id;
    die "ERROR: Invalid metric id [$id]."         unless ($id =~ /^\d+$/);

    if (defined $params && ref($params) eq 'HASH') {
        my $data = [
            { key => 'name'             , required => 0 },
            { key => 'url'              , required => 0 },
            { key => 'sharing'          , required => 0 },
            { key => 'include_in_email' , required => 0 },
        ];

        validate($data, $params);

        die "ERROR: Missing keys to update." unless (scalar(keys %$params));

        if (exists $params->{sharing}
            && defined $params->{sharing}
            && ($params->{sharing} =~ /\bpublic\b/i)) {
            die "ERROR: Invalid data for key 'url'."
                unless (exists $params->{url} && defined $params->{url});
        }
        if (exists $params->{url} && defined $params->{url}) {
            die "ERROR: Invalid data for key 'sharing'."
                unless (exists $params->{sharing}
                        && defined $params->{sharing}
                        && ($params->{sharing} =~ /\bpublic\b/i));
        }
    }
    else {
        die "ERROR: Parameters have to be hash ref.";
    }

    my $url      = sprintf("%s/%d.json", $self->metrics_url, $id);
    my $response = $self->put($url, [ %$params ]);
    my $content  = from_json($response->content);

    return WWW::StatsMix::Metric->new($content->{metric});
}

=head2 delete_metric($metric_id)

It deletes the metric and returns the object of type L. It
requires mandatory 'metric_id'.

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY   = "Your_API_Key";
   my $api       = WWW::StatsMix->new(api_key => $API_KEY);
   my $metric_id = ;
   my $metric    = $api->delete_metric($metric_id);

   print "Name: ", $metric->name, "\n";

=cut

sub delete_metric {
    my ($self, $id) = @_;

    die "ERROR: Missing the required key metric id."       unless defined $id;
    die "ERROR: Invalid the required key metric id [$id]." unless ($id =~ /^\d+$/);

    my $url      = sprintf("%s/%d.json", $self->metrics_url, $id);
    my $response = $self->delete($url);
    my $content  = from_json($response->content);

    return WWW::StatsMix::Metric->new($content->{metric});
}

=head2 get_metrics(\%params)

The method get_metrics() will return a default of up to 50 records. The parameter
limit  can  be  passed  to specify the number of records to return. The parameter
profile_id  can also be used to scope records to a particular profile. Parameters
start_date &  end_date can be used to limit the date range based on the timestamp
in a stat's generated_at.
The result of the call is reference to list of L objects.

   +------------+---------------------------------------------------------------+
   | Key        | Description                                                   |
   +------------+---------------------------------------------------------------+
   | limit      | Limit the number of metrics. Default is 50.                   |
   | (optional) |                                                               |
   |            |                                                               |
   | profile_id | Scope the search to a particular profile.                     |
   | (optional) |                                                               |
   |            |                                                               |
   | start_date | Limit the searh in date range against stats generated_at key. |
   | / end_date | Valid format is YYYY-MM-DD.                                   |
   | (optional) |                                                               |
   +------------+---------------------------------------------------------------+

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY    = "Your_API_Key";
   my $api        = WWW::StatsMix->new(api_key => $API_KEY);
   my $profile_id = ;
   my $limit      = ;

   my $metrics_all        = $api->get_metrics;
   my $metrics_by_limit   = $api->get_metrics({ limit      => $limit      });
   my $metrics_by_profile = $api->get_metrics({ profile_id => $profile_id });

=cut

sub get_metrics {
    my ($self, $params) = @_;

    my $url = sprintf("%s?format=%s", $self->metrics_url, $self->format);
    if (defined $params) {
        my $data = [
            { key => 'limit'     , required => 0 },
            { key => 'profile_id', required => 0 },
            { key => 'start_date', required => 0 },
            { key => 'end_date'  , required => 0 },
        ];
        validate($data, $params);

        if (exists $params->{start_date} && defined $params->{start_date}) {
            die "ERROR: Missing param key 'end_date'."
                unless (exists $params->{end_date} && defined $params->{end_date});
            die "ERROR: Invalid param key 'start_date'."
                unless _is_valid_date($params->{start_date});
            die "ERROR: Invalid param key 'end_date'."
                unless _is_valid_date($params->{end_date});
        }
        elsif (exists $params->{end_date} && defined $params->{end_date}) {
            die "ERROR: Missing param key 'start_date'."
                unless (exists $params->{start_date} && defined $params->{start_date});
        }

        foreach (qw(limit profile_id start_date end_date)) {
            if (exists $params->{$_} && defined $params->{$_}) {
                $url .= sprintf("&%s=%s", $_, $params->{$_});
            }
        }
    }

    my $response = $self->get($url);
    my $content  = from_json($response->content);

    return _get_metrics($content);
}

=head2 create_stat(\%params)

The  method  create_stat() creates stat for the given metric. You can also create
stat with ref_id. It returns an object of type L.

   +--------------+-------------------------------------------------------------+
   | Key          | Description                                                 |
   +--------------+-------------------------------------------------------------+
   | metric_id    | The metric id for which the stat would be created.          |
   | (required)   |                                                             |
   |              |                                                             |
   | value        | The numeric value of the stat with a decimal precision of   |
   | (required)   | two. Decimal (up to 11 digits on the left side of the       |
   |              | decimal point, two on the right).                           |
   |              |                                                             |
   | generated_at | Datetime for the stat. If not set, defaults to the current. |
   | (optional)   | timestamp. This is the datetime to be used in the charts.   |
   |              | Valid format is YYYY-MM-DD.                                 |
   |              |                                                             |
   | meta         | hash ref data (key,value pair) about anything associated    |
   | (optional)   | with the stat.                                              |
   |              |                                                             |
   | ref_id       | Optional reference id for a stat. If a stat already exists  |
   | (optional)   | for the named metric and the given ref_id, the value (and   |
   |              | optionally generated_at and meta) will be updated instead of|
   |              | created.                                                    |
   +--------------+-------------------------------------------------------------+

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY   = "Your_API_Key";
   my $api       = WWW::StatsMix->new(api_key => $API_KEY);
   my $metric_id = ;
   my $value     = ;
   my $params    = { metric_id => $metric_id, value => $value };
   my $stat      = $api->create_stat($params);

   print "Id: ", $stat->id, "\n";

=cut

sub create_stat {
    my ($self, $params) = @_;

    my $data = [
        { key => 'metric_id'   , required => 1 },
        { key => 'value'       , required => 1 },
        { key => 'generated_at', required => 0 },
        { key => 'meta'        , required => 0 },
        { key => 'ref_id'      , required => 0 }
    ];
    validate($data, $params);

    if (exists $params->{meta} && defined $params->{meta}) {
        die "ERROR: Invalid data format for key 'meta'."
            unless (ref($params->{meta}) eq 'HASH');
        $params->{meta} = to_json($params->{meta});
    }

    $params->{format} = $self->format;
    my $response = $self->post($self->stats_url, [ %$params ]);
    my $content  = from_json($response->content);

    return WWW::StatsMix::Stat->new($content->{stat});
}

=head2 get_stat($metric_id, \%params)

Returns the stat details of the given stat of the metric. The stat can  be either
search by stat id or ref id. The return data is of type L.It
requires  mandatory  key  'metric_id'. If both 'id' and 'ref_id' are defined then
'id' takes the precedence.

   +--------+-------------------------------------------------------------------+
   | Key    | Description                                                       |
   +--------+-------------------------------------------------------------------+
   | id     | Id of the stat. Required only if 'ref_id' is undefined.           |
   |        |                                                                   |
   | ref_id | Ref id of the stat. Required only if 'id' is undefined.           |
   +--------+-------------------------------------------------------------------+

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY     = "Your_API_Key";
   my $api         = WWW::StatsMix->new(api_key => $API_KEY);
   my $metric_id   = ;
   my $stat_id     = ;
   my $stat_ref_id = ;

   my $stat_by_id     = $api->get_stat($metric_id, { id     => $stat_id     });
   my $stat_by_ref_id = $api->get_stat($metric_id, { ref_id => $stat_ref_id });

   print "Stat by Id (name)    : ", $stat_by_id->name,     "\n";
   print "Stat by Ref Id (name): ", $stat_by_ref_id->name, "\n";

=cut

sub get_stat {
    my ($self, $metric, $params) = @_;

    die "ERROR: Missing the required key metric id."           unless defined $metric;
    die "ERROR: Invalid the required key metric id [$metric]." unless ($metric =~ /^\d+$/);

    my $data = [
        { key => 'id'    , required => 0 },
        { key => 'ref_id', required => 0 }
    ];
    validate($data, $params);

    my $id       = _get_id($params);
    my $url      = sprintf("%s/%d.json?metric_id=%d", $self->stats_url, $id, $metric);
    my $response = $self->get($url);
    my $content  = from_json($response->content);

    return WWW::StatsMix::Stat->new($content->{stat});
}

=head2 update_stat($metric_id, \%params)

Update the stat of the metric.Stat can be located by stat id or ref id.Parameters
for the method are as below. The return data is of type L.It
requires mandatory key 'metric_id' and params as hash ref. Following keys can  be
passed  in  hash ref. If  both  'id' and 'ref_id' are defined then 'id' takes the
precedence.

   +------------+---------------------------------------------------------------+
   | Key        | Description                                                   |
   +------------+---------------------------------------------------------------+
   | value      | The numeric value of the stat with a decimal precision of two.|
   | (required) | Decimal (up to 11 digits on the left side of the decimal      |
   |            | point, two on the right).                                     |
   |            |                                                               |
   | id         | Id of the stat. Required only if 'ref_id' is undefined.       |
   |            |                                                               |
   | ref_id     | Ref id of the stat. Required only if 'id' is undefined.       |
   +------------+---------------------------------------------------------------+

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY     = "Your_API_Key";
   my $api         = WWW::StatsMix->new(api_key => $API_KEY);
   my $metric_id   = ;
   my $value       = ;
   my $stat_id     = ;
   my $stat_ref_id = ;

   my $stat_by_id     = $api->update_stat($metric_id, { id     => $stat_id,     value => $value });
   my $stat_by_ref_id = $api->update_stat($metric_id, { ref_id => $stat_ref_id, value => $value });

   print "Stat by Id (value)    : ", $stat_by_id->value,     "\n";
   print "Stat by Ref Id (value): ", $stat_by_ref_id->value, "\n";

=cut

sub update_stat {
    my ($self, $metric, $params) = @_;

    die "ERROR: Missing the required key metric id."           unless defined $metric;
    die "ERROR: Invalid the required key metric id [$metric]." unless ($metric =~ /^\d+$/);

    my $data = [
        { key => 'value' , required => 1 },
        { key => 'id'    , required => 0 },
        { key => 'ref_id', required => 0 }
    ];
    validate($data, $params);

    my $id       = _get_id($params);
    my $value    = _get_value($params);
    my $_data    = { metric_id => $metric, value => $value };
    my $url      = sprintf("%s/%d.json", $self->stats_url, $id);
    my $response = $self->put($url, [ %$_data ]);
    my $content  = from_json($response->content);

    return WWW::StatsMix::Stat->new($content->{stat});
}

=head2 delete_stat($metric_id, \%params)

Delete the stat of the metric.Stat can be located by stat id or ref id.Parameters
for the method are as below. The return data is of type L.It
requires mandatory key 'metric_id' and params as hash ref. The hash  ref can have
either 'id' or 'ref_id'. If both specified then 'id' takes the precedence.

   +--------+-------------------------------------------------------------------+
   | Key    | Description                                                       |
   +--------+-------------------------------------------------------------------+
   | id     | Id of the stat. Required only if 'ref_id' is undefined.           |
   |        |                                                                   |
   | ref_id | Ref id of the stat. Required only if 'id' is undefined.           |
   +--------+-------------------------------------------------------------------+

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY     = "Your_API_Key";
   my $api         = WWW::StatsMix->new(api_key => $API_KEY);
   my $metric_id   = ;
   my $stat_id     = ;
   my $stat_ref_id = ;

   my $stat_by_id     = $api->delete_stat($metric_id, { id     => $stat_id     });
   my $stat_by_ref_id = $api->delete_stat($metric_id, { ref_id => $stat_ref_id });

=cut

sub delete_stat {
    my ($self, $metric, $params) = @_;

    die "ERROR: Missing the required key metric id."           unless defined $metric;
    die "ERROR: Invalid the required key metric id [$metric]." unless ($metric =~ /^\d+$/);

    my $data = [
        { key => 'id'    , required => 0 },
        { key => 'ref_id', required => 0 }
    ];
    validate($data, $params);

    my $id       = _get_id($params);
    my $url      = sprintf("%s/%d.json?metric_id=%d", $self->stats_url, $id, $metric);
    my $response = $self->delete($url);
    my $content  = from_json($response->content);

    return WWW::StatsMix::Stat->new($content->{stat});
}

=head2 get_stats(\%params)

The method get_stats() will return a default of up to 50  records.  The parameter
limit  can  be  passed  to specify the number of records to return. The parameter
metric_id  can also be used to scope records to a particular profile. Parameters
start_date &  end_date can be used to limit the date range based on the timestamp
in a stat's generated_at.

   +------------+---------------------------------------------------------------+
   | Key        | Description                                                   |
   +------------+---------------------------------------------------------------+
   | limit      | Limit the number of metrics. Default is 50.                   |
   | (optional) |                                                               |
   |            |                                                               |
   | metric_id  | Scope the search to a particular metric.                      |
   | (optional) |                                                               |
   |            |                                                               |
   | start_date | Limit the searh in date range against stats generated_at key. |
   | / end_date | Valid format is YYYY-MM-DD.                                   |
   | (optional) |                                                               |
   +------------+---------------------------------------------------------------+

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY   = "Your_API_Key";
   my $api       = WWW::StatsMix->new(api_key => $API_KEY);
   my $metric_id = ;
   my $limit     = ;

   my $stats = $api->get_stats();
   my $stats_by_metric = $api->get_stats({ metric_id => $metric_id });
   my $stats_by_metric_by_limit = $api->get_stats({ metric_id => $metric_id, limit => $limit });

=cut

sub get_stats {
    my ($self, $params) = @_;

    my $url = sprintf("%s?format=%s", $self->stats_url, $self->format);
    if (defined $params) {
        my $data = [
            { key => 'limit'     , required => 0 },
            { key => 'metric_id' , required => 0 },
            { key => 'start_date', required => 0 },
            { key => 'end_date'  , required => 0 },
        ];
        validate($data, $params);

        if (exists $params->{start_date} && defined $params->{start_date}) {
            die "ERROR: Missing param key 'end_date'."
                unless (exists $params->{end_date} && defined $params->{end_date});
            die "ERROR: Invalid param key 'start_date'."
                unless _is_valid_date($params->{start_date});
            die "ERROR: Invalid param key 'end_date'."
                unless _is_valid_date($params->{end_date});
        }
        elsif (exists $params->{end_date} && defined $params->{end_date}) {
            die "ERROR: Missing param key 'start_date'."
                unless (exists $params->{start_date} && defined $params->{start_date});
        }

        foreach (qw(limit metric_id start_date end_date)) {
            if (exists $params->{$_} && defined $params->{$_}) {
                $url .= sprintf("&%s=%s", $_, $params->{$_});
            }
        }
    }

    my $response = $self->get($url);
    my $content  = from_json($response->content);

    return _get_stats($content);
}

=head2 track(\%params)

It combines the functions create_stat() and create_metric() (if necessary) into a
single method call. If no value is passed, the default of 1 is returned.  Returns
an object of type L.

   +--------------+-------------------------------------------------------------+
   | Key          | Description                                                 |
   +--------------+-------------------------------------------------------------+
   | name         | The name of the metric you are tracking. If a metric with   |
   | (required)   | that name does not exist in your account, one will be       |
   |              | created automatically,                                      |
   |              |                                                             |
   | value        | The numeric value of the stat with a decimal precision of   |
   | (optional)   | two. Decimal (up to 11 digits on the left side of the       |
   |              | decimal point, two on the right). If missing default value  |
   |              | 1 is assigned.                                              |
   |              |                                                             |
   | generated_at | Datetime for the stat. If not set, defaults to the current  |
   | (optional)   | timestaamp. This is the datetime to be used in the charts.  |
   |              | Valid format is YYYY-MM-DD.                                 |
   |              |                                                             |
   | meta         | hashref data (key,value pair) about anything associated with|
   | (optional)   | the stat.                                                   |
   |              |                                                             |
   | ref_id       | Optional reference id for a stat. If a stat already exists  |
   | (optional)   | for the named metric and the given ref_id, the value (and   |
   |              | optionally generated_at and meta) will be updated instead of|
   |              | created.                                                    |
   |              |                                                             |
   | profile_id   | The unique id of the profile this stat belongs to. If not   |
   | (optional)   | set, the metric will use the first profile_id created in    |
   |              | your account. (Developer, Basic and Standard plans only have|
   |              | one profile.)                                               |
   +--------------+-------------------------------------------------------------+

   use strict; use warnings;
   use WWW::StatsMix;

   my $API_KEY = "Your_API_Key";
   my $api     = WWW::StatsMix->new(api_key => $API_KEY);
   my $name    = ;
   my $params  = { name => $metric_name };
   my $stat    = $api->track($params);

   print "Id: ", $stat->id, "\n";

=cut

sub track {
    my ($self, $params) = @_;

    my $data = [
        { key => 'name'        , required => 1 },
        { key => 'value'       , required => 0 },
        { key => 'generated_at', required => 0 },
        { key => 'meta'        , required => 0 },
        { key => 'ref_id'      , required => 0 },
        { key => 'profile_id'  , required => 0 }
    ];
    validate($data, $params);

    $params->{meta} = to_json($params->{meta})
        if (exists $params->{meta} && defined $params->{meta});

    $params->{format} = $self->format;
    my $response = $self->post($self->track_url, [ %$params ]);
    my $content  = from_json($response->content);

    return WWW::StatsMix::Stat->new($content->{stat});
}

# PRIVATE METHODS
#
#

sub _get_id {
    my ($params) = @_;

    if (defined $params && (ref($params) eq 'HASH')) {
        if (exists $params->{id} && defined $params->{id}) {
            return $params->{id};
        }
        elsif (exists $params->{ref_id} && defined $params->{ref_id}) {
            return $params->{ref_id};
        }
    }

    die "ERROR: Missing required key id/ref_id";
}

sub _get_value {
    my ($params) = @_;

    return $params->{value}
        if (defined $params && exists $params->{value} && defined $params->{value});

    die "ERROR: Missing required key 'value'.";
}

sub _get_metrics {
    my ($content) = @_;

    my $metrics = [];
    foreach (@{$content->{metrics}->{metric}}) {
        push @$metrics, WWW::StatsMix::Metric->new($_);
    }

    return $metrics;
}

sub _get_stats {
    my ($content) = @_;

    my $stats = [];
    foreach (@{$content->{stats}->{stat}}) {
        push @$stats, WWW::StatsMix::Stat->new($_);
    }

    return $stats;
}

sub _now_yyyy_mm_dd_hh_mi_ss {
    my ($sec,$min,$hour,$mday,$mon,$year) = localtime(time);
    return sprintf("%04d-%02d-%02d %02d:%02d:%02d", $year+=1900, ++$mon, $mday, $hour, $min, $sec);
}

sub _now_yyyy_mm_dd {
    my ($sec,$min,$hour,$mday,$mon,$year) = localtime(time);
    return sprintf("%04d-%02d-%02d", $year+=1900, ++$mon, $mday);
}

=head1 AUTHOR

Mohammad S Anwar, C<<  >>

=head1 REPOSITORY

L

=head1 BUGS

Please report any bugs or feature requests to C,
or through the web interface at L.
I will be notified, and then you'll automatically be notified of progress on your
bug as I make changes.

=head1 SUPPORT

You can find documentation for this module with the perldoc command.

    perldoc WWW::StatsMix

You can also look for information at:

=over 4

=item * RT: CPAN's request tracker (report bugs here)

L

=item * AnnoCPAN: Annotated CPAN documentation

L

=item * CPAN Ratings

L

=item * Search CPAN

L

=back

=head1 LICENSE AND COPYRIGHT

Copyright (C) 2014 - 2015 Mohammad S Anwar.

This  program  is  free software; you can redistribute it and/or modify it under
the  terms  of the the Artistic License (2.0). You may obtain a copy of the full
license at:

L

Any  use,  modification, and distribution of the Standard or Modified Versions is
governed by this Artistic License.By using, modifying or distributing the Package,
you accept this license. Do not use, modify, or distribute the Package, if you do
not accept this license.

If your Modified Version has been derived from a Modified Version made by someone
other than you,you are nevertheless required to ensure that your Modified Version
 complies with the requirements of this license.

This  license  does  not grant you the right to use any trademark,  service mark,
tradename, or logo of the Copyright Holder.

This license includes the non-exclusive, worldwide, free-of-charge patent license
to make,  have made, use,  offer to sell, sell, import and otherwise transfer the
Package with respect to any patent claims licensable by the Copyright Holder that
are  necessarily  infringed  by  the  Package. If you institute patent litigation
(including  a  cross-claim  or  counterclaim) against any party alleging that the
Package constitutes direct or contributory patent infringement,then this Artistic
License to you shall terminate on the date that such litigation is filed.

Disclaimer  of  Warranty:  THE  PACKAGE  IS  PROVIDED BY THE COPYRIGHT HOLDER AND
CONTRIBUTORS  "AS IS'  AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED
WARRANTIES    OF   MERCHANTABILITY,   FITNESS   FOR   A   PARTICULAR  PURPOSE, OR
NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS
REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL,  OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE
OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=cut

1; # End of WWW::StatsMix