File Coverage

blib/lib/WWW/Picnic.pm

Criterion	Covered	Total	%
statement	92	134	68.6
branch	9	28	32.1
condition	5	17	29.4
subroutine	24	29	82.7
pod	16	17	94.1
total	146	225	64.8

package WWW::Picnic;
our $VERSION = '0.100';
our $AUTHORITY = 'cpan:GETTY';
# ABSTRACT: Library to access Picnic Supermarket API

use Moo;

use Carp qw( croak );
use JSON::MaybeXS;
use HTTP::Request;
use LWP::UserAgent;
use Digest::MD5 qw( md5_hex );

use WWW::Picnic::Result::Login;
use WWW::Picnic::Result::User;
use WWW::Picnic::Result::Cart;
use WWW::Picnic::Result::DeliverySlots;
use WWW::Picnic::Result::Search;
use WWW::Picnic::Result::Article;


has user => (
  is => 'ro',
  required => 1,
);


has pass => (
  is => 'ro',
  required => 1,
);


has client_id => (
  is => 'ro',
  default => sub { 30100 },
);


has api_version => (
  isa => sub { $_[0] >= 15 },
  is => 'ro',
  default => sub { 15 },
);


has country => (
  is => 'ro',
  default => sub { 'de' },
);


sub api_endpoint {
  my ( $self ) = @_;
  return sprintf('https://storefront-prod.%s.picnicinternational.com/api/%s', $self->country, "".$self->api_version."");
}

has http_agent => (
  is => 'ro',
  lazy => 1,
  default => sub {
    my $self = shift;
    my $ua = LWP::UserAgent->new;
    $ua->agent($self->http_agent_name);
    return $ua;
  },
);


has http_agent_name => (
  is => 'ro',
  lazy => 1,
  default => sub { 'okhttp/3.12.2' },
);


has picnic_agent => (
  is => 'ro',
  lazy => 1,
  default => sub { '30100;1.15.232-15154' },
);


has picnic_did => (
  is => 'ro',
  lazy => 1,
  default => sub {
    # Generate a random device ID (16 hex chars)
    my @chars = ('0'..'9', 'A'..'F');
    return join '', map { $chars[rand @chars] } 1..16;
  },
);


has json => (
  is => 'ro',
  lazy => 1,
  default => sub { return JSON::MaybeXS->new->utf8 },
);

has _auth_cache => (
  is => 'ro',
  default => sub {{}},
);

sub login {
  my ( $self ) = @_;
  my $url = URI->new(join('/',$self->api_endpoint,'user','login'));
  my $request = HTTP::Request->new( POST => $url );
  $request->header('Accept' => 'application/json');
  $request->header('Content-Type' => 'application/json; charset=UTF-8');
  $request->content($self->json->encode({
    key => $self->user,
    secret => md5_hex($self->pass),
    client_id => $self->client_id,
  }));
  my $response = $self->http_agent->request($request);
  if ($response->is_success) {
    my $auth = $response->header('X-Picnic-Auth');
    my $data = $self->json->decode($response->content);
    $data->{auth_key} = $auth;
    if ($auth && $data->{user_id} && !$data->{second_factor_authentication_required}) {
      $self->_auth_cache->{auth} = $auth;
      $self->_auth_cache->{time} = time;
      $self->_auth_cache->{user_id} = $data->{user_id};
    }
    return WWW::Picnic::Result::Login->new($data);
  } else {
    croak __PACKAGE__.": login failed! ".$response->status_line;
  }
}


sub generate_2fa_code {
  my ( $self, $channel ) = @_;
  $channel //= 'SMS';
  my $url = URI->new(join('/',$self->api_endpoint,'user','2fa','generate'));
  my $request = HTTP::Request->new( POST => $url );
  $request->header('Accept' => 'application/json');
  $request->header('Content-Type' => 'application/json; charset=UTF-8');
  $request->content($self->json->encode({ channel => $channel }));
  my $response = $self->http_agent->request($request);
  unless ($response->is_success) {
    croak __PACKAGE__.": 2FA code generation failed! ".$response->status_line;
  }
  return 1;
}


sub verify_2fa_code {
  my ( $self, $code ) = @_;
  croak __PACKAGE__.": 2FA code required" unless defined $code;
  my $url = URI->new(join('/',$self->api_endpoint,'user','2fa','verify'));
  my $request = HTTP::Request->new( POST => $url );
  $request->header('Accept' => 'application/json');
  $request->header('Content-Type' => 'application/json; charset=UTF-8');
  $request->content($self->json->encode({ otp => $code }));
  my $response = $self->http_agent->request($request);
  if ($response->is_success) {
    my $auth = $response->header('X-Picnic-Auth');
    croak __PACKAGE__.": 2FA verify success, but no auth token!" unless $auth;
    my $data = $self->json->decode($response->content);
    $self->_auth_cache->{auth} = $auth;
    $self->_auth_cache->{time} = time;
    $self->_auth_cache->{user_id} = $data->{user_id} if $data->{user_id};
    return 1;
  } else {
    croak __PACKAGE__.": 2FA verification failed! ".$response->status_line;
  }
}


sub picnic_auth {
  my ( $self ) = @_;
  unless (defined $self->_auth_cache->{auth}) {
    my $login = $self->login;
    if ($login->requires_2fa) {
      croak __PACKAGE__.": 2FA required! Call login() and handle 2FA flow manually.";
    }
    unless ($self->_auth_cache->{auth}) {
      croak __PACKAGE__.": login failed to obtain auth token!";
    }
  }
  return $self->_auth_cache->{auth};
}


sub request {
  my ( $self, @original_args ) = @_;
  my ( $method, $path, $data, %params ) = @original_args;
  $data = [] if $method eq 'PUT' and !$data;
  my $url = URI->new(join('/',$self->api_endpoint,$path));
  if (%params) {
    $url->query_form(%params);
  }
  my $request = HTTP::Request->new( $method => $url );
  $request->header('Accept' => 'application/json');
  $request->header('X-Picnic-Auth' => $self->picnic_auth );
  $request->header('X-Picnic-Agent' => $self->picnic_agent );
  $request->header('X-Picnic-Did' => $self->picnic_did );
  if (defined $data) {
    $request->header('Content-Type' => 'application/json');
    $request->content($self->json->encode($data));
  }
  my $response = $self->http_agent->request($request);
  unless ($response->is_success) {
    croak __PACKAGE__.": request to ".$url->as_string." failed! ".$response->status_line;
  }
  return $self->json->decode($response->content);
}


sub get_user {
  my ( $self ) = @_;
  return WWW::Picnic::Result::User->new( $self->request( GET => 'user' ) );
}


sub get_cart {
  my ( $self ) = @_;
  return WWW::Picnic::Result::Cart->new( $self->request( GET => 'cart' ) );
}


sub clear_cart {
  my ( $self ) = @_;
  return WWW::Picnic::Result::Cart->new( $self->request( POST => 'cart/clear' ) );
}


sub get_delivery_slots {
  my ( $self ) = @_;
  return WWW::Picnic::Result::DeliverySlots->new( $self->request( GET => 'cart/delivery_slots' ) );
}


sub search {
  my ( $self, $term ) = @_;
  return WWW::Picnic::Result::Search->new( $self->request( GET => 'pages/search-page-results', undef, search_term => $term ) );
}


sub get_article {
  my ( $self, $product_id ) = @_;
  return WWW::Picnic::Result::Article->new( $self->request( GET => "articles/$product_id" ) );
}


sub add_to_cart {
  my ( $self, $product_id, $count ) = @_;
  $count //= 1;
  return WWW::Picnic::Result::Cart->new(
    $self->request( POST => 'cart/add_product', { product_id => $product_id, count => $count } )
  );
}


sub remove_from_cart {
  my ( $self, $product_id, $count ) = @_;
  $count //= 1;
  return WWW::Picnic::Result::Cart->new(
    $self->request( POST => 'cart/remove_product', { product_id => $product_id, count => $count } )
  );
}


sub set_delivery_slot {
  my ( $self, $slot_id ) = @_;
  return WWW::Picnic::Result::Cart->new(
    $self->request( POST => 'cart/set_delivery_slot', { slot_id => $slot_id } )
  );
}


sub get_categories {
  my ( $self, $depth ) = @_;
  $depth //= 0;
  return $self->request( GET => 'my_store', undef, depth => $depth );
}


sub get_suggestions {
  my ( $self, $term ) = @_;
  return $self->request( GET => 'suggest', undef, search_term => $term );
}


1;

__END__