def refresh_stored_tokens():
# refresh stored QBO tokens
callback_url = app.config.get('CALLBACK_URL')
realm_id = fetch('realm_id')
session_manager = Oauth2SessionManager(
client_id=fetch('qb_id'),
client_secret=fetch('qb_secret'),
base_url=callback_url,
access_token=fetch('access_token'),
refresh_token=fetch('refresh_token'),
)
result = session_manager.refresh_access_tokens(return_result=True)
save('access_token', session_manager.access_token)
save('refresh_token', session_manager.refresh_token)
session_manager = Oauth2SessionManager(
client_id=realm_id,
client_secret=fetch('qb_secret'),
access_token=fetch('access_token'),
)
sandbox = fetch('qb_sandbox')
qbclient = QuickBooks(sandbox=sandbox,
session_manager=session_manager,
company_id=realm_id)
QuickBooks.enable_global()
save('session_manager', session_manager)
save('qbclient', qbclient)
return str(result)
def get_qb_client():
from .models import User
master_user = User.objects.get(qb_master_user=True)
session_manager = Oauth2SessionManager(
client_id=settings.QUICKBOOKS_CLIENT_ID,
client_secret=settings.QUICKBOOKS_CLIENT_SECRET,
access_token=master_user.qb_access_token,
refresh_token=master_user.qb_refresh_token,
)
expire_time_with_buffer = (master_user.qb_expires_in or now()) - timedelta(seconds=60)
if now() > expire_time_with_buffer:
session_manager.refresh_access_tokens()
master_user.qb_expires_in = now() + timedelta(seconds=session_manager.expires_in)
session_manager.start_session()
master_user.qb_access_token = session_manager.access_token
master_user.qb_refresh_token = session_manager.refresh_token
master_user.save()
return QuickBooks(
sandbox=settings.IS_SANDBOX,
session_manager=session_manager,
consumer_key=settings.QUICKBOOKS_CLIENT_ID,
consumer_secret=settings.QUICKBOOKS_CLIENT_SECRET,
company_id=settings.QUICKBOOKS_COMPANY_ID,
minorversion=4
)
def get_qb_client():
if not settings.QB_ACTIVE:
return None, None
try:
profile = Profile.objects.filter(qb_valid=True)[0]
except IndexError:
return None, None
if profile.qb_valid:
session_manager = Oauth2SessionManager(
client_id=settings.QB_CLIENT_ID,
client_secret=settings.QB_CLIENT_SECRET,
access_token=profile.qb_access_token,
)
if profile.qb_token_expires < datetime.datetime.now():
session_manager = profile.refresh_qb_session_manager()
if settings.QB_ENVIRONMENT == "production":
sandbox = False
else:
sandbox = True
client = QuickBooks(
sandbox=sandbox,
session_manager=session_manager,
company_id=profile.qb_realm_id,
minorversion=36,
)
return client, profile
def qbo_callback():
# https://github.com/sidecars/python-quickbooks
from quickbooks import Oauth2SessionManager
from quickbooks import QuickBooks
error = request.args.get('error', '')
if error:
return "Error: " + error
state = request.args.get('state', '')
if not is_valid_state(state):
# Uh-oh, this request wasn't started by us!
abort(403)
authorization_code = request.args.get('code')
realm_id = request.args.get('realmId')
session_manager = Oauth2SessionManager(
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
base_url='http://localhost:8000/qbo_callback',
)
session_manager.get_access_tokens(authorization_code)
access_token = session_manager.access_token
session_manager = Oauth2SessionManager(
client_id=realm_id,
client_secret=CLIENT_SECRET,
access_token=access_token,
)
client = QuickBooks(
sandbox=True,
session_manager=session_manager,
company_id=realm_id
)
from quickbooks.objects.customer import Customer
customers = Customer.all(qb=client)
import_googlesheets(customers)
client.disconnect_account()
# Note: In most cases, you'll want to store the access token, in, say,
# a session for use in other parts of your web app.
return "Your qbo authorization_code is %s realm_id is: %s customers: %s" % (authorization_code, realm_id, customers)
def post(self, request, *args, **kwargs):
if request.POST.get("qb") == "qb-connect":
session_manager = Oauth2SessionManager(
client_id=settings.QB_CLIENT_ID,
client_secret=settings.QB_CLIENT_SECRET,
base_url=settings.QB_CALLBACK_URL,
)
authorize_url = session_manager.get_authorize_url(
settings.QB_CALLBACK_URL)
return redirect(authorize_url)
def get_auth_url():
# asks Intuit server for a valid authorization URL
# returns authorization URL
callback_url = app.config.get('CALLBACK_URL')
session_manager = Oauth2SessionManager(
client_id=fetch('qb_id'),
client_secret=fetch('qb_secret'),
base_url=callback_url,
)
authorize_url = session_manager.get_authorize_url(callback_url)
return authorize_url
def connect(self):
session_manager = Oauth2SessionManager(
client_id=AUTH['quickbooks_client_id'],
client_secret=AUTH['quickbooks_client_secret'],
access_token=TOKENS['access_token'])
logger.info("starting session...")
session_manager.start_session()
logger.info("initializing QuickBooks client...")
self.client = QuickBooks(session_manager=session_manager,
company_id=AUTH['realm_id'],
sandbox=CONFIG['app']['sandbox'])
def extract(start_date, end_date):
"""
Connect to the shopify API and pull orders for the given time period
:param start_date: timestamp indicating beginning of time range
:param end_date: timestamp indicating end of time range
:return: list of JSON responses
"""
logger.info('Begin Extract')
# Create session
session_manager = Oauth2SessionManager(
client_id=cfg['quickbooks_client_id'],
client_secret=cfg['quickbooks_client_secret'],
access_token=cfg['quickbooks_access_token'],
base_url='https://developer.intuit.com/v2/OAuth2Playground/RedirectUrl'
)
# Refresh token and save to config
refresh = session_manager.refresh_access_tokens(
cfg['quickbooks_refresh_token'], return_result=True)
cfg['quickbooks_access_token'] = refresh['access_token']
cfg['quickbooks_refresh_token'] = refresh['refresh_token']
# Create client
client = QuickBooks(sandbox=False,
session_manager=session_manager,
company_id=cfg['quickbooks_realm_id'],
refresh_token=cfg['quickbooks_refresh_token'],
minorversion=4)
# Get total number of reports
response = client.query("""
select count(*) from Invoice
where TxnDate > '{}' and TxnDate < '{}'
""".format(start_date, end_date))
num_invoices = response['QueryResponse']['totalCount']
orders = []
for page in range(round(num_invoices / 25)):
response = client.query("""
select * from Invoice
where TxnDate > '{}' and TxnDate < '{}'
STARTPOSITION {} MAXRESULTS {}
""".format(start_date, end_date, (page * 25 + 1), 25))
orders.append(response)
logger.info('Data Extraction completed successfully')
return orders
def set_global_vars(realmid, code):
# stores Intuit tokens
# stores QBO client object
# stores session manager object for future token refreshes
callback_url = app.config.get('CALLBACK_URL')
session_manager = Oauth2SessionManager(
client_id=fetch('qb_id'),
client_secret=fetch('qb_secret'),
base_url=callback_url,
)
realm_id = realmid
data = session_manager.get_access_tokens(
auth_code=code,
return_result=True,
)
# sanity check: if no valid response from Intuit, abort fn
if 'token_type' not in data:
return None
access_token = session_manager.access_token
refresh_token = session_manager.refresh_token
session_manager = Oauth2SessionManager(
client_id=realm_id,
client_secret=fetch('qb_secret'),
access_token=access_token,
)
sandbox = fetch('qb_sandbox')
qbclient = QuickBooks(sandbox=sandbox,
session_manager=session_manager,
company_id=realm_id)
QuickBooks.enable_global()
save('realm_id', realm_id)
save('access_token', access_token)
save('refresh_token', refresh_token)
save('session_manager', session_manager)
save('qbclient', qbclient)
from app import tasks
def connect(self):
logger.warning("--------------- I am in connect of controller() ---------------")
clientkey = clientsecret = reconfig_idsquest_token_url = ''
access_token_url = authorization_base_url = ''
callbck_url = request.env['ir.config_parameter'].get_param('web.base.url')
url = callbck_url + '/page/quickbook'
logger.warning("This the the callback url %s",url)
quick_config_obj = request.env['quick.configuration']
config_ids = quick_config_obj.search([])
clientkey = config_ids.clientkey
clientsecret = config_ids.clientsecret
session_manager = Oauth2SessionManager(client_id=clientkey, client_secret=clientsecret, base_url=url, )
callback_url = url
authorize_url = session_manager.get_authorize_url(callback_url)
return [authorize_url, session_manager]
def extract():
"""
Get all customers on file
:return: list of JSON responses
"""
logger.info('Begin Extract')
# Create session
session_manager = Oauth2SessionManager(
client_id=cfg['quickbooks_client_id'],
client_secret=cfg['quickbooks_client_secret'],
access_token=cfg['quickbooks_access_token'],
base_url='https://developer.intuit.com/v2/OAuth2Playground/RedirectUrl'
)
# Refresh token and save to config
refresh = session_manager.refresh_access_tokens(
cfg['quickbooks_refresh_token'], return_result=True)
cfg['quickbooks_access_token'] = refresh['access_token']
cfg['quickbooks_refresh_token'] = refresh['refresh_token']
# Create client
client = QuickBooks(sandbox=False,
session_manager=session_manager,
company_id=cfg['quickbooks_realm_id'],
refresh_token=cfg['quickbooks_refresh_token'],
minorversion=4)
# Get total number of reports
response = client.query("""
select count(*) from Customers
""")
num_customers = response['QueryResponse']['totalCount']
customers = []
for page in range(round(num_customers / 25)):
response = client.query("""
select * from Customers
STARTPOSITION {} MAXRESULTS {}
""".format((page * 25 + 1), 25))
customers.append(response)
logger.info('Data Extraction completed successfully')
return customers
def update_qb_session_manager(self, code, realm_id):
session_manager = Oauth2SessionManager(
client_id=settings.QB_CLIENT_ID,
client_secret=settings.QB_CLIENT_SECRET,
base_url=settings.QB_CALLBACK_URL,
)
session_manager.get_access_tokens(code)
self.qb_access_token = session_manager.access_token
self.qb_refresh_token = session_manager.refresh_token
self.qb_valid = True
self.qb_token_expires = arrow.now().shift(seconds=3600).datetime
self.qb_refresh_expires = arrow.now().shift(seconds=8726400).datetime
self.qb_realm_id = realm_id
self.save()
Profile.objects.all().exclude(pk=self.id).update(qb_valid=False)
def make_authorization_url():
import requests
# https://github.com/sidecars/python-quickbooks
from quickbooks import Oauth2SessionManager
session_manager = Oauth2SessionManager(
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
base_url='http://localhost:8000/qbo_callback',
)
callback_url = 'http://localhost:8000/qbo_callback' # Quickbooks will send the response to this url
authorize_url = session_manager.get_authorize_url(callback_url)
requests.get(authorize_url)
return authorize_url
def __init__(self, **kwargs):
if 'user_id' in kwargs:
self.user_id = kwargs['user_id']
user_connection = self.__get_user_client_credential()
self.client_id = user_connection.consumer_key
self.client_secret = user_connection.consumer_secret
self.company_id = user_connection.company_id
self.refresh_token = user_connection.refresh_token
self.access_token = user_connection.access_token
self.session_manager = Oauth2SessionManager(
client_id=self.client_id,
client_secret=self.client_secret,
access_token=self.access_token)
self.get_new_auth_token()
# self.session_manager.access_token = self.access_token
self.client = QuickBooks(sandbox=settings.QB_SANDBOX,
session_manager=self.session_manager,
company_id=self.company_id)
from quickbooks import Oauth2SessionManager
client_id = "Q0AaC7Zk5JlBRJqGjBkLthuJ7RV8Jpdg8xab0vtviZAYJWF16g"
client_secret = "s5I3D2Wn22tsbcXcUwkdrVV5d1LGcH7bTimWD6Bb"
session_manager = Oauth2SessionManager(sandbox=True,
client_id=client_id,
client_secret=client_secret,
base_url='http://localhost:8001')
callback_url = 'http://localhost:8000'
authorize_url = client.get_authorization_url(callback_url)
request_token = client.request_token
request_token_secret = client.request_token_secret