def test_verification_using_bad_auth_uri(self, r_request):
credentials = OAuth2Credentials('client_id', 'client_secret',
auth_state='test_state')
bad_auth_uri = '{}?error=access_denied&state={}'.format(
self.callback_uri, credentials.auth_state
)
with self.assertRaises(XeroAccessDenied):
credentials.verify(bad_auth_uri)
with self.assertRaises(XeroAccessDenied):
OAuth2Credentials('client_id', 'client_secret',
auth_state='test_state',
auth_secret=bad_auth_uri)
self.assertFalse(r_request.called)
def get(self, request):
form = InvoiceForm()
cred_state = cache.get('xero_creds')
credentials = OAuth2Credentials(**cred_state)
auth_secret = request.get_raw_uri()
credentials.verify(auth_secret)
credentials.set_default_tenant()
cred_state = credentials.state
credentials = OAuth2Credentials(**cred_state)
cache.set('xero_creds', credentials.state)
if credentials.expired():
credentials.refresh()
cache.set('xero_creds', credentials.state)
return render(request,'activate.html', context={'form':form})
def xero_oauth2():
credentials = OAuth2Credentials(client_id, client_secret, callback_uri=callback_uri)
authorization_url = credentials.generate_url()
cache.set('xero_creds',credentials.state)
return redirect(authorization_url)
def xero():
cred_state = caches['default'].get('xero_creds')
credentials = OAuth2Credentials(**cred_state)
if credentials.expired():
credentials.refresh()
caches['default'].set('xero_creds', credentials.state)
return Xero(credentials)
def test_set_default_tenant(self, get_tenants):
get_tenants.return_value = [{"id": "1", "tenantId": "12345",
"tenantType": "ORGANISATION"}]
credentials = OAuth2Credentials('client_id', 'client_secret',
token=self.expired_token)
credentials.set_default_tenant()
self.assertEqual(credentials.tenant_id, "12345")
def test_tenant_id_not_set_raises_error(self):
credentials = OAuth2Credentials("client_id",
"client_secret",
token=self.expired_token)
xero = Xero(credentials)
with self.assertRaises(XeroTenantIdNotSet):
xero.contacts.all()
def submit(request):
data = cache.get('data', None)
cred_state = cache.get('creds',None)
if 'invoice' not in data:
return redirect('Oauth:add')
if 'invoice' in data and 'Contact' not in data['invoice']:
return redirect('Oauth:add')
if 'tenant_id' in cred_state:
try:
credentials = OAuth2Credentials(**cred_state)
xero = Xero(credentials)
print(xero)
print("karunga")
print(data['invoice'])
d = data['invoice']
print(d)
d = beautify(d)
xero.invoices.put(d)
cache.set('data', {})
return JsonResponse(d, safe=False)
except:
return HttpResponse("Wrong Values Entered Check Again")
else:
return redirect('Oauth:index')
def test_verification_success(self, r_request):
credentials = OAuth2Credentials('client_id', 'client_secret',
auth_state='test_state')
auth_uri = '{}?code=0123456789&scope={}&state={}'.format(
self.callback_uri, '%20'.join(credentials.scope),
credentials.auth_state
)
r_request.return_value = Mock(
status_code=200,
request=Mock(headers={}, body=''),
headers={},
text='{"access_token":"1234567890","expires_in":1800,'
'"token_type":"Bearer","refresh_token":"0987654321"}'
)
credentials.verify(auth_uri)
self.assertTrue(r_request.called)
self.assertTrue(credentials.token)
self.assertTrue(credentials.oauth)
self.assertFalse(credentials.expired())
# Finally test the state
self.assertEqual(
credentials.state,
{
'client_id': credentials.client_id,
'client_secret': credentials.client_secret,
'auth_state': credentials.auth_state,
'scope': credentials.scope,
'user_agent': credentials.user_agent,
'token': credentials.token
}
)
def process_callback_view(request):
cred_state = caches['mycache'].get('xero_creds')
credentials = OAuth2Credentials(**cred_state)
auth_secret = request.get_raw_uri()
credentials.verify(auth_secret)
credentials.set_default_tenant()
caches['mycache'].set('xero_creds', credentials.state)
def test_verification_success(self, r_request):
credentials = OAuth2Credentials("client_id",
"client_secret",
auth_state="test_state")
auth_uri = "{}?code=0123456789&scope={}&state={}".format(
self.callback_uri, "%20".join(credentials.scope),
credentials.auth_state)
r_request.return_value = Mock(
status_code=200,
request=Mock(headers={}, body=""),
headers={},
text='{"access_token":"1234567890","expires_in":1800,'
'"token_type":"Bearer","refresh_token":"0987654321"}',
)
credentials.verify(auth_uri)
self.assertTrue(r_request.called)
self.assertTrue(credentials.token)
self.assertTrue(credentials.oauth)
self.assertFalse(credentials.expired())
# Finally test the state
self.assertEqual(
credentials.state,
{
"client_id": credentials.client_id,
"client_secret": credentials.client_secret,
"auth_state": credentials.auth_state,
"scope": credentials.scope,
"user_agent": credentials.user_agent,
"token": credentials.token,
},
)
def index(request):
credentials = OAuth2Credentials(client_id, client_secret, scope=my_scope,
callback_uri=callback_uri)
authorisation_url = credentials.generate_url()
cache.set('creds', credentials.state)
cache.set('data', {})
return redirect(authorisation_url)
def test_authorisation_url_using_initial_state(self):
credentials = OAuth2Credentials('client_id', 'client_secret',
callback_uri=self.callback_uri,
auth_state='test_state')
url = urlparse(credentials.generate_url())
self.assertEqual(credentials.auth_state, 'test_state')
qs = parse_qs(url.query)
self.assertEqual(qs['state'][0], 'test_state')
def xero_callback():
cred_state = cache.get('xero_creds')
credentials = OAuth2Credentials(**cred_state)
auth_secret = request.url
credentials.verify(auth_secret)
credentials.set_default_tenant()
cache.set('xero_creds',credentials.state)
return redirect('/xero')
def post(self, request):
credentials = OAuth2Credentials(
client_id, client_secret, callback_uri=callback_uri,
scope=[XeroScopes.OFFLINE_ACCESS, XeroScopes.ACCOUNTING_CONTACTS,
XeroScopes.ACCOUNTING_TRANSACTIONS]
)
authorization_url = credentials.generate_url()
cache.set('xero_creds', credentials.state)
return HttpResponseRedirect(authorization_url)
def calls_xero(request):
cred_state = caches['mycache'].get('xero_creds')
credentials = OAuth2Credentials(**cred_state)
if credentials.expired():
credentials.refresh()
caches['mycache'].set('xero_creds', credentials.state)
xero = Xero(credentials)
contacts = xero.contacts.all()
def test_verification_failure(self, r_request):
credentials = OAuth2Credentials('client_id', 'client_secret',
auth_state='test_state')
auth_uri = '{}?code=0123456789&scope={}&state={}'.format(
self.callback_uri, '%20'.join(credentials.scope),
credentials.auth_state
)
r_request.return_value = Mock(
status_code=400,
request=Mock(headers={}, body=''),
headers={},
text='{"error":"invalid_grant"}'
)
with self.assertRaises(XeroAccessDenied):
credentials.verify(auth_uri)
with self.assertRaises(XeroAccessDenied):
OAuth2Credentials('client_id', 'client_secret',
auth_state='test_state',
auth_secret=auth_uri)
def start_xero_auth_view(request): client_id = "___________________________" client_secret = "_____________________________________" credentials = OAuth2Credentials(client_id, client_secret, callback_uri="http://localhost:8000/logged/") # credentials = PublicCredentials(client_id, client_secret) authorization_url = credentials.generate_url() # authorization_url = credentials.url request.session['xero_creds'] = credentials.state return HttpResponseRedirect(authorization_url)
def process_callback_view(request):
cred_state = caches['default'].get('xero_creds')
credentials = OAuth2Credentials(**cred_state)
auth_secret = 'https://' + request.META['HTTP_HOST'] + request.META[
'RAW_URI']
credentials.verify(auth_secret)
credentials.set_default_tenant()
caches['default'].set('xero_creds', credentials.state)
return HttpResponse()
def test_authorisation_url_using_initial_state(self):
credentials = OAuth2Credentials(
"client_id",
"client_secret",
callback_uri=self.callback_uri,
auth_state="test_state",
)
url = urlparse(credentials.generate_url())
self.assertEqual(credentials.auth_state, "test_state")
qs = parse_qs(url.query)
self.assertEqual(qs["state"][0], "test_state")
def XeroFirstAuth(request):
credentials = OAuth2Credentials('client_id',
'client_secret',
callback_uri='https://xero.com/',
scope=[
XeroScopes.OFFLINE_ACCESS,
XeroScopes.ACCOUNTING_CONTACTS,
XeroScopes.ACCOUNTING_TRANSACTIONS
])
authorization_url = credentials.generate_url()
caches['mycache'].set('xero_creds', credentials.state)
return HttpResponseRedirect(authorization_url)
def auth(request):
global mycache
cred_state = cache.get('creds',None)
print(cred_state)
print(cred_state)
credentials = OAuth2Credentials(**cred_state)
credentials.verify(request.get_raw_uri())
tenants = credentials.get_tenants()
credentials.tenant_id = tenants[0]['tenantId']
cache.set('creds',credentials.state)
return redirect('Oauth:add')
def test_tenant_is_used_in_xero_request(self, r_get):
credentials = OAuth2Credentials('client_id', 'client_secret',
token=self.expired_token,
tenant_id='12345')
xero = Xero(credentials)
# Just return any old response
r_get.return_value = None
try:
xero.contacts.all()
except:
pass
self.assertEqual(r_get.call_args[1]['headers']['Xero-tenant-id'], '12345')
def xero_view():
cred_state = cache.get('xero_creds')
credentials = OAuth2Credentials(**cred_state)
if credentials.expired():
credentials.refresh()
cred_state = cache.get('xero_creds')
credentials = OAuth2Credentials(**cred_state)
cache.set('xero_creds',credentials.state)
xero = XeroApiWrapper(credentials=credentials)
my_groups = xero.contactgroups.all()
my_contact_groups_name = [x['Name'] for x in my_groups]
my_contact_groups_name = list( dict.fromkeys(my_contact_groups_name)) # Remove duplicates
cache.set('default_select_group',my_groups[0])
allContacts = xero.contacts.all()
postal_regions = []
for contact in allContacts:
if "Region" in contact['Addresses'][0]:
postal_regions.append(contact['Addresses'][0]["Region"].strip())
postal_regions = list( dict.fromkeys(postal_regions))
postal_regions.append("All") # Select all options
cache.set('success'," ")
directory=os.getcwd()+ "/dump/"
files = glob.glob(directory+'*.csv')
for f in files:
try:
os.remove(f)
except OSError as e:
print("Error: %s : %s" % (f, e.strerror))
return render_template('xero.html',contact_group_list=my_contact_groups_name,postal_states_list=postal_regions,success_message=cache.get('success'))
def test_tenant_is_used_in_xero_request(self, r_get):
credentials = OAuth2Credentials("client_id",
"client_secret",
token=self.expired_token,
tenant_id="12345")
xero = Xero(credentials)
# Just return any old response
r_get.return_value = None
try:
xero.contacts.all()
except: # NOQA: E722
pass
self.assertEqual(r_get.call_args[1]["headers"]["Xero-tenant-id"],
"12345")
def test_authorisation_url_and_random_state(self):
credentials = OAuth2Credentials('client_id', 'client_secret',
callback_uri=self.callback_uri)
url = credentials.generate_url()
self.assertTrue(url.startswith(XERO_OAUTH2_AUTHORIZE_URL))
qs = parse_qs(urlparse(url).query)
# Test that the credentials object can be dumped by state
cred_state = credentials.state
# Then test that the relevant attributes are in the querystring
self.assertEqual(qs['client_id'][0], cred_state['client_id'])
self.assertEqual(qs['redirect_uri'][0], cred_state['callback_uri'])
self.assertEqual(qs['response_type'][0], 'code')
self.assertEqual(qs['scope'][0], " ".join(cred_state['scope']))
self.assertEqual(qs['state'][0], cred_state['auth_state'])
def start_xero_auth_view(request):
client_id = getattr(settings, 'XERO2_CLIENT_KEY', None)
client_secret = getattr(settings, 'XERO2_CLIENT_SECRET', None)
callback_uri = ""
credentials = OAuth2Credentials(client_id,
client_secret,
callback_uri=callback_uri,
scope=[
XeroScopes.OFFLINE_ACCESS,
XeroScopes.ACCOUNTING_CONTACTS,
XeroScopes.ACCOUNTING_TRANSACTIONS
])
authorization_url = credentials.generate_url()
caches['default'].set('xero_creds', credentials.state)
return HttpResponseRedirect(authorization_url)
def start_xero_auth_view(request):
# Get client_id, client_secret from config file or settings then
credentials = OAuth2Credentials(
settings.XERO_CLIENT_ID,
settings.XERO_CLIENT_SECRET,
callback_uri=
"https://donations.effectivealtruism.org.au/process_callback",
scope=[
XeroScopes.OFFLINE_ACCESS, XeroScopes.ACCOUNTING_CONTACTS,
XeroScopes.ACCOUNTING_REPORTS_READ,
XeroScopes.ACCOUNTING_TRANSACTIONS
])
authorization_url = credentials.generate_url()
caches['default'].set('xero_creds', credentials.state)
return HttpResponseRedirect(authorization_url)
def test_get_tenants(self, r_get):
credentials = OAuth2Credentials('client_id', 'client_secret',
token=self.expired_token)
content = '[{"id":"1","tenantId":"12345","tenantType":"ORGANISATION"}]'
def json_fct():
return json.loads(content)
r_get.return_value = Mock(
status_code=200,
json=json_fct
)
tenants = credentials.get_tenants()
self.assertTrue(r_get.called)
self.assertEqual(tenants,
[{"id": "1", "tenantId": "12345", "tenantType": "ORGANISATION"}])
def get(self, request):
try:
""" Handle the get request. """
print("XeroOAuth2CallbackView - START")
cred_state = caches['default'].get('xero_creds')
print("XeroOAuth2CallbackView - cred_state")
credentials = OAuth2Credentials(**cred_state)
print("XeroOAuth2CallbackView - credentials")
auth_secret = request.get_raw_uri()
print("XeroOAuth2CallbackView - auth_secret")
auth_secret = auth_secret.replace("http:", "https:")
credentials.verify(auth_secret)
credentials.set_default_tenant()
caches['default'].set('xero_creds', credentials.state)
#added after invoicing worked
return HttpResponseRedirect("/static/index.html#")
except Exception as e:
print(e)
def test_token_refresh(self, r_post):
credentials = OAuth2Credentials('client_id', 'client_secret',
token=self.expired_token)
self.assertTrue(credentials.oauth)
self.assertTrue(credentials.expired())
r_post.return_value = Mock(status_code=200,
headers={},
text='{"access_token":"5555555555","expires_in":1800,'
'"token_type":"Bearer","refresh_token":"44444444444"}'
)
credentials.refresh()
self.assertTrue(r_post.called)
self.assertFalse(credentials.expired())
# Test that the headers were set correctly
auth = r_post.call_args[1]['auth']
self.assertEqual(auth.username, 'client_id')
self.assertEqual(auth.password, 'client_secret')
