use
version;
our
$VERSION
= qv(
'400'
);
has
'is_success'
=> (
is
=>
'rw'
);
has
'cache'
=> (
is
=>
'rw'
);
has
'invalid'
=> (
is
=>
'rw'
);
has
'test_mode'
=> (
is
=>
'rw'
);
has
'user_id'
=> (
is
=>
'rw'
);
has
'password'
=> (
is
=>
'rw'
);
has
'cache_time'
=> (
is
=>
'rw'
);
has
'results'
=> (
is
=>
'rw'
,
isa
=>
'HashRef'
);
has
'_tracking_ids'
=> (
is
=>
'rw'
,
isa
=>
'ArrayRef'
);
has
'packages'
=> (
is
=>
'rw'
,
isa
=>
'ArrayRef[Business::Shipping::Package]'
,
default
=>
sub
{ [Business::Shipping::Package->new()] },
auto_deref
=> 1
);
has
'user_agent'
=> (
is
=>
'rw'
,
isa
=>
'LWP::UserAgent'
,
default
=>
sub
{ LWP::UserAgent->new() },
);
has
'response'
=> (
is
=>
'rw'
,
isa
=>
'HTTP::Response'
,
default
=>
sub
{ HTTP::Response->new() },
);
__PACKAGE__->meta()->make_immutable();
sub
Required {
return
(
$_
[0]->SUPER::Required,
qw/ user_id password /
);
}
sub
Optional {
return
(
$_
[0]->SUPER::Required,
qw/ prod_url test_url /
);
}
sub
_delete_undefined_keys {
my
$hash_ref
=
shift
;
map
{
if
(
defined
(
$hash_ref
->{
$_
}) &&
ref
(
$hash_ref
->{
$_
}) eq
'HASH'
)
{
_delete_undefined_keys(
$hash_ref
->{
$_
});
if
(
scalar
(
keys
%{
$hash_ref
->{
$_
} }) == 0) {
delete
$hash_ref
->{
$_
};
}
}
elsif
(
defined
(
$hash_ref
->{
$_
})
&&
ref
(
$hash_ref
->{
$_
}) eq
'ARRAY'
)
{
foreach
my
$element
(@{
$hash_ref
->{
$_
} }) {
if
(
ref
(
$element
) eq
'HASH'
) {
_delete_undefined_keys(
$element
);
}
}
}
elsif
(!
defined
(
$hash_ref
->{
$_
})) {
delete
$hash_ref
->{
$_
};
}
}
keys
%$hash_ref
;
}
sub
submit {
my
(
$self
,
%args
) =
@_
;
trace(
'()'
);
$self
->init(
%args
)
if
%args
;
$self
->validate() or
return
;
my
$cache_results
;
if
(
$self
->cache()) {
trace(
'cache enabled'
);
my
$cache
= Cache::FileCache->new();
foreach
my
$id
(@{
$self
->tracking_ids }) {
my
$key
=
$self
->gen_unique_key(
$id
);
info
"cache key = $key\n"
;
my
$cache_result
=
$cache
->get(
$key
);
if
(
defined
(
$cache_result
)) {
$cache_results
->{
$id
} =
$cache_result
;
}
else
{
trace(
"Cache miss on id $id, running request manually, then add to cache."
);
}
}
$self
->results(
%$cache_results
);
}
else
{
trace(
'cache disabled'
);
}
my
@requests
=
$self
->_gen_request();
while
(
my
$request
=
shift
@requests
) {
trace(
'Please wait while we get a response from the server...'
);
$self
->response(
$self
->_get_response(
$request
));
trace(
"response content = "
.
$self
->response()->content());
if
(!
$self
->response()->is_success()) {
$self
->user_error(
"HTTP Error. Status line: "
.
$self
->response->status_line
.
"Content: "
.
$self
->response->content());
$self
->is_success(0);
last
;
}
$self
->_handle_response();
if
(
scalar
(
@requests
) > 0) {
trace
'sleeping for 2 seconds'
;
sleep
2;
}
}
if
(
$self
->cache()) {
trace(
'cache enabled, saving results.'
);
my
$new_cache
= Cache::FileCache->new();
foreach
my
$id
(
$self
->results_keys) {
my
$key
=
$self
->gen_unique_key(
$id
);
if
(
exists
(
$cache_results
->{
$id
})) {
next
;
}
my
$value
=
$self
->results_index(
$id
);
$new_cache
->set(
$key
,
$value
,
(
$self
->cache_time() ||
"12 hours"
));
}
}
else
{
trace(
'cache disabled, not saving results.'
);
}
$self
->is_success(1);
return
$self
->is_success();
}
sub
validate {
my
(
$self
) =
@_
;
trace
'()'
;
if
(
scalar
(@{
$self
->tracking_ids() }) == 0) {
$self
->invalid(1);
$self
->user_error(
"No tracking ids passed to track"
);
return
0;
}
if
(!
defined
(
$self
->user_id)) {
$self
->invalid(1);
$self
->user_error(
"No user_id specified"
);
return
0;
}
if
(!
defined
(
$self
->password)) {
$self
->invalid(1);
$self
->user_error(
"No password specified"
);
return
0;
}
return
1;
}
sub
_get_response {
trace
'()'
;
return
$_
[0]->user_agent->request(
$_
[1]);
}
sub
tracking_ids {
my
$self
=
shift
;
$self
->_tracking_ids(
$_
[0])
if
(
ref
(
$_
[0]) eq
'ARRAY'
);
$self
->_tracking_ids(\
@_
)
if
@_
;
return
@{
$self
->_tracking_ids() }
if
wantarray
();
return
$self
->_tracking_ids();
}
sub
results_exists {
my
(
$self
,
$key
) =
@_
;
my
$results_hash
=
$self
->results;
return
1
if
exists
$results_hash
->{
$key
};
return
0;
}
1;