optionally calculate Suretax taxes based only on the service location, #32043
[freeside.git] / FS / FS / part_export / acct_google.pm
1 package FS::part_export::acct_google;
2
3 use strict;
4 use vars qw(%info %SIG $CACHE);
5 use Tie::IxHash;
6
7 use base 'FS::part_export';
8
9 tie my %options, 'Tie::IxHash',
10   'domain'    => { label => 'Domain name' },
11   'username'  => { label => 'Admin username' },
12   'password'  => { label => 'Admin password' },
13 ;
14 # To handle multiple domains, use separate instances of 
15 # the export.  We assume that they all have different 
16 # admin logins.
17
18 %info = (
19   'svc'        => 'svc_acct',
20   'desc'       => 'Google hosted mail',
21   'options'    => \%options,
22   'nodomain'   => 'Y',
23   'no_machine' => 1,
24   'default_svc_class' => 'Email',
25   'notes'    => <<'END'
26 Export accounts to the Google Provisioning API.  Requires 
27 REST::Google::Apps::Provisioning from CPAN.
28 END
29 );
30
31 sub rebless { shift; }
32
33 sub _export_insert {
34   my($self, $svc_acct) = (shift, shift);
35   $svc_acct->finger =~ /^(.*)\s+(\S+)$/;
36   my ($first, $last) = ($1, $2);
37   $self->google_request('createUser',
38     'username'      => $svc_acct->username,
39     'password'      => $svc_acct->_password,
40     'givenName'     => $first,
41     'familyName'    => $last,
42   );
43 }
44
45 sub _export_replace {
46   my( $self, $new, $old ) = (shift, shift, shift);
47   # We have to do this in two steps, so do the renameUser last so that 
48   # if it fails partway through the username is still coherent.
49   if ( $new->_password ne $old->_password
50     or $new->finger    ne $old->finger ) {
51     $new->finger =~ /^(.*)\s+(\S+)$/;
52     my ($first, $last) = ($1, $2);
53     my $error = $self->google_request('updateUser',
54       'username'    => $old->username,
55       'password'    => $new->_password,
56       'givenName'   => $first,
57       'familyName'  => $last,
58     );
59     return $error if $error;
60   }
61   if ( $new->username ne $old->username ) {
62     my $error = $self->google_request('renameUser',
63       'username'  => $old->username,
64       'newname'   => $new->username
65     );
66     return $error if $error;
67   }
68   return;
69 }
70
71 sub _export_delete {
72   my( $self, $svc_acct ) = (shift, shift);
73   $self->google_request('deleteUser',
74     'username'  => $svc_acct->username
75   );
76 }
77
78 sub _export_suspend {
79   my( $self, $svc_acct ) = (shift, shift);
80   $self->google_request('updateUser',
81     'username'  => $svc_acct->username,
82     'suspended' => 'true',
83   );
84 }
85
86 sub _export_unsuspend {
87   my( $self, $svc_acct ) = (shift, shift);
88   $self->google_request('updateUser',
89     'username'  => $svc_acct->username,
90     'suspended' => 'false',
91   );
92 }
93
94 sub auth_error {
95   my $self = shift;
96   my $google = $self->google_handle;
97   if ( $google->{'error'} ) {
98     my $url = $google->{'captcha_url'} || '';
99     $url = "http://www.google.com/accounts/$url" if $url;
100     return { 'captcha_url' => $url,
101              'message'     => 
102                'Unable to connect to the Google API: '.$google->{'error'}.'.',
103            };
104   }
105   return; #nothing on success
106 }
107
108 sub captcha_auth {
109   my $self = shift;
110   my $response = shift;
111   my $google = $self->google_handle('captcha_response' => $response);
112   return (defined($google->{'token'}));
113 }
114
115 my %google_error = (
116   1000 => 'unknown error',
117   1001 => 'server busy',
118   1100 => 'username belongs to a recently deleted account',
119   1101 => 'user suspended',
120   1200 => 'domain user limit exceeded',
121   1201 => 'domain alias limit exceeded',
122   1202 => 'domain suspended',
123   1203 => 'feature not available on this domain',
124   1300 => 'username in use',
125   1301 => 'user not found',
126   1302 => 'reserved username',
127   1400 => 'illegal character in first name',
128   1401 => 'illegal character in last name',
129   1402 => 'invalid password',
130   1403 => 'illegal character in username',
131   # should be everything we need
132 );
133
134 # Runs the request and returns nothing if it succeeds, or an 
135 # error message.
136
137 sub google_request {
138   my ($self, $method, %opt) = @_;
139   my $google = $self->google_handle(
140     'captcha_response' => delete $opt{'captcha_response'}
141   );
142   return $google->{'error'} if $google->{'error'};
143
144   # Throw away the result from this; we don't use it yet.
145   eval { $google->$method(%opt) };
146   if ( $@ ) {
147     return $google_error{ $@->{'error'}->{'errorCode'} } || $@->{'error'};
148   }
149   return;
150 }
151
152 # Returns a REST::Google::Apps::Provisioning object which is hooked 
153 # to die {error => stuff} on API errors.  The cached auth token 
154 # will be used if possible.  If not, try to authenticate.  On 
155 # authentication error, the R:G:A:P object will still be returned 
156 # but with $google->{'error'} set to the error message.
157
158 sub google_handle {
159   my $self = shift;
160   my %opt = @_;
161   my @class = ( 
162     'REST::Google::Apps::Provisioning',
163     'Cache::FileCache',
164     'LWP::UserAgent 5.815',
165   );
166   foreach (@class) {
167     eval "use $_";
168     die "failed to load $_\n" if $@;
169   }
170   $CACHE ||= new Cache::FileCache( {
171       'namespace'   => __PACKAGE__,
172       'cache_root'  => "$FS::UID::cache_dir/cache.$FS::UID::datasrc",
173   } );
174   my $google = REST::Google::Apps::Provisioning->new(
175     'domain'  => $self->option('domain') 
176   );
177
178   # REST::Google::Apps::Provisioning lacks error reporting.  We deal 
179   # with that by hooking HTTP::Response to throw a useful fatal error 
180   # on failure.
181   $google->{'lwp'}->add_handler( 'response_done' =>
182     sub {
183       my $response = shift;
184       return if $response->is_success;
185
186       my $error = '';
187       if ( $response->content =~ /^</ ) {
188         #presume xml
189         $error = $google->{'xml'}->parse_string($response->content);
190       }
191       elsif ( $response->content =~ /=/ ) {
192         $error = +{ map { if ( /^(\w+)=(.*)$/ ) { lc($1) => $2 } }
193           split("\n", $response->content)
194         };
195       }
196       else { # have something to say if there is no response...
197         $error = {'error' => $response->status_line};
198       }
199       die $error;
200     }
201   );
202
203   my $cache_token = $self->exportnum . '_token';
204   my $cache_captcha = $self->exportnum . '_captcha_token';
205   $google->{'token'} = $CACHE->get($cache_token);
206   if ( !$google->{'token'} ) {
207     my %login = (
208       'username' => $self->option('username'),
209       'password' => $self->option('password'),
210     );
211     if ( $opt{'captcha_response'} ) {
212       $login{'logincaptcha'} = $opt{'captcha_response'};
213       $login{'logintoken'} = $CACHE->get($cache_captcha);
214     }
215     eval { $google->captcha_auth(%login); };
216     if ( $@ ) {
217       $google->{'error'} = $@->{'error'};
218       $google->{'captcha_url'} = $@->{'captchaurl'};
219       $CACHE->set($cache_captcha, $@->{'captchatoken'}, '1 minute');
220       return $google;
221     }
222     $CACHE->remove($cache_captcha);
223     $CACHE->set($cache_token, $google->{'token'}, '1 hour');
224   }
225   return $google;
226 }
227
228 # REST::Google::Apps::Provisioning also lacks a way to do this
229 sub REST::Google::Apps::Provisioning::captcha_auth {
230   my $self = shift;
231
232   return( 1 ) if $self->{'token'};
233
234   my ( $arg );
235   %{$arg} = @_;
236
237   map { $arg->{lc($_)} = $arg->{$_} } keys %{$arg};
238
239   foreach my $param ( qw/ username password / ) {
240     $arg->{$param} || croak( "Missing required '$param' argument" );
241   }
242
243   my @postargs = (
244     'accountType' => 'HOSTED',
245     'service'     => 'apps',
246     'Email'       => $arg->{'username'} . '@' . $self->{'domain'},
247     'Passwd'      => $arg->{'password'},
248   );
249   if ( $arg->{'logincaptcha'} ) {
250     push @postargs, 
251       'logintoken'  => $arg->{'logintoken'},
252       'logincaptcha'=> $arg->{'logincaptcha'}
253       ;
254   }
255   my $response = $self->{'lwp'}->post(
256     'https://www.google.com/accounts/ClientLogin',
257     \@postargs
258   );
259
260   $response->is_success() || return( 0 );
261
262   foreach ( split( /\n/, $response->content() ) ) {
263     $self->{'token'} = $1 if /^Auth=(.+)$/;
264     last if $self->{'token'};
265   }
266
267   return( 1 ) if $self->{'token'} || return( 0 );
268 }
269
270 1;