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 quickbooks_callback():
consumer_key = current_app.config.get('QUICKBOOKS_OAUTH_CONSUMER_KEY')
consumer_secret = current_app.config.get('QUICKBOOKS_OAUTH_CONSUMER_SECRET')
app_token = current_app.config.get('QUICKBOOKS_APP_TOKEN')
callback_url = current_app.config.get('QUICKBOOKS_CALLBACK_URL')
print request.args
oauth_token = request.args.get('oauth_token')
oauth_verifier = request.args.get('oauth_verifier')
oauth_token_secret = request.args.get('oauth_token_secret')
qb = QuickBooks(
consumer_key=consumer_key,
consumer_secret=consumer_secret,
callback_url=callback_url)
qb.my_get_access_tokens(oauth_token, oauth_verifier, oauth_token_secret, consumer_secret)
access_token = qb.access_token
access_token_secret = qb.access_token_secret
print 'access token: %s' %(access_token)
print 'access token secret %s' %(access_token_secret)
qbm = Quickbooks_model(oauth_verifier=oauth_verifier, realm_id=realm_id,username = current_user.email, access_token=access_token, access_token_secret=access_token_secret)
db.session.add(qbm)
db.session.commit()
db.session.close()
return render_template('oauth_success.html', service="Quickbooks")
def quickbooks_callback():
consumer_key = current_app.config.get('QUICKBOOKS_OAUTH_CONSUMER_KEY')
consumer_secret = current_app.config.get(
'QUICKBOOKS_OAUTH_CONSUMER_SECRET')
app_token = current_app.config.get('QUICKBOOKS_APP_TOKEN')
callback_url = current_app.config.get('QUICKBOOKS_CALLBACK_URL')
print request.args
oauth_token = request.args.get('oauth_token')
oauth_verifier = request.args.get('oauth_verifier')
oauth_token_secret = request.args.get('oauth_token_secret')
qb = QuickBooks(consumer_key=consumer_key,
consumer_secret=consumer_secret,
callback_url=callback_url)
qb.my_get_access_tokens(oauth_token, oauth_verifier, oauth_token_secret,
consumer_secret)
access_token = qb.access_token
access_token_secret = qb.access_token_secret
print 'access token: %s' % (access_token)
print 'access token secret %s' % (access_token_secret)
qbm = Quickbooks_model(oauth_verifier=oauth_verifier,
realm_id=realm_id,
username=current_user.email,
access_token=access_token,
access_token_secret=access_token_secret)
db.session.add(qbm)
db.session.commit()
db.session.close()
return render_template('oauth_success.html', service="Quickbooks")
def querycutomized(cls, select, qb=None):
"""
:param select: QBO SQL query select statement
:param qb:
:return: Returns list
"""
if not qb:
qb = QuickBooks()
json_data = qb.query(select)
return json_data
def get_client(realm, refresh_token):
'''
Create the QuickBooks client object from the auth client.
'''
QuickBooks.enable_global()
qb = QuickBooks(auth_client=current_app.quickbooks_auth_client,
refresh_token=refresh_token,
company_id=realm)
return qb
def quickbooks():
print 'inside quickbooks granturl'
consumer_key = current_app.config.get('QUICKBOOKS_OAUTH_CONSUMER_KEY')
consumer_secret = current_app.config.get('QUICKBOOKS_OAUTH_CONSUMER_SECRET')
app_token = current_app.config.get('QUICKBOOKS_APP_TOKEN')
callback_url = current_app.config.get('QUICKBOOKS_CALLBACK_URL')
qb = QuickBooks(
consumer_key=consumer_key,
consumer_secret=consumer_secret,
callback_url=callback_url)
global_qb = qb
oauth_path = qb.get_authorize_url()
return redirect(oauth_path)
def quickbooks():
print 'inside quickbooks granturl'
consumer_key = current_app.config.get('QUICKBOOKS_OAUTH_CONSUMER_KEY')
consumer_secret = current_app.config.get(
'QUICKBOOKS_OAUTH_CONSUMER_SECRET')
app_token = current_app.config.get('QUICKBOOKS_APP_TOKEN')
callback_url = current_app.config.get('QUICKBOOKS_CALLBACK_URL')
qb = QuickBooks(consumer_key=consumer_key,
consumer_secret=consumer_secret,
callback_url=callback_url)
global_qb = qb
oauth_path = qb.get_authorize_url()
return redirect(oauth_path)
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 account(request):
auth_client = AuthClient(
settings.CLIENT_ID,
settings.CLIENT_SECRET,
settings.REDIRECT_URI,
settings.ENVIRONMENT,
access_token=request.session.get('access_token', None),
refresh_token=request.session.get('refresh_token', None),
realm_id=request.session.get('realm_id', None),
)
client = QuickBooks(
auth_client=auth_client,
refresh_token=request.session.get('refresh_token', None),
company_id=4620816365030839390,
)
from quickbooks.objects.account import Account
accounts = Account.all(qb=client)
print(accounts)
if auth_client.access_token is not None:
access_token = auth_client.access_token
if auth_client.realm_id is None:
raise ValueError('Realm id not specified.')
response = get_account_info(auth_client.access_token, auth_client.realm_id)
if not response.ok:
return HttpResponse(' '.join([response.content, str(response.status_code)]))
else:
response = response.json()["QueryResponse"]
return JsonResponse(response)
def get_quickbooks_client():
env = environ.Env()
auth_client = AuthClient(
client_id=env("QUICKBOOKS_CLIENT"),
client_secret=env("QUICKBOOKS_SECRET"),
environment="production",
redirect_uri="http://localhost:8000/callback",
)
token_path = str(settings.ROOT_DIR / "secrets" /
"QUICKBOOKS_REFRESH_TOKEN")
if os.path.exists(token_path):
with open(token_path, "r") as refresh_token_file:
refresh_token = refresh_token_file.read()
else:
print("NEED TO GENERATE REFRESH TOKEN!")
return
auth_client.refresh(refresh_token=refresh_token)
with open(token_path, "w") as refresh_token_file:
refresh_token_file.write(auth_client.refresh_token)
client = QuickBooks(
auth_client=auth_client,
refresh_token=auth_client.refresh_token,
company_id="9130348538823906",
minorversion=62,
)
return client
def setUp(self):
self.qb_client = QuickBooks(
sandbox=True,
consumer_key="update_consumer_key",
consumer_secret="update_consumer_secret",
access_token="update_access_token",
access_token_secret="update_access_token_secret",
company_id="update_company_id",
callback_url="update_callback_url")
self.cdc_json_response = {
"CDCResponse": [{
"QueryResponse": [{
"Customer": [{
"Id": 1,
"DisplayName": "TestCustomer",
"Job": False,
"Balance": 0
}],
"startPosition":
1,
"maxResults":
1
}, {
"Invoice": [
{
"DocNumber": "12344",
"TxnDate": "2017-01-01",
"Line": [{
"Id": 1
}, {
"Id": 2
}]
},
{
"DocNumber": "12345",
"TxnDate": "2017-01-01",
"Line": [{
"Id": 1
}, {
"Id": 2
}]
},
],
"startPosition":
1,
"maxResults":
2
}]
}],
"time":
"2016-01-01T00:00:00"
}
self.cdc_empty_json_response = {
"CDCResponse": [{
"QueryResponse": [{}]
}],
"time": "2019-03-13T10:24:05.179-07:00"
}
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 oauth_handler():
# Get the uhh get params
auth_code = request.args.get('code')
state = request.args.get('state')
realm_id = request.args.get('realmId')
# Get bearer token
auth_client.get_bearer_token(auth_code, realm_id=realm_id)
response = auth_client.get_user_info()
session['is_authorised'] = True
session['token'] = auth_client.access_token
session['access_token'] = auth_client.access_token
session['refresh_token'] = auth_client.refresh_token
session['company_id'] = realm_id
session['user_info'] = response.json()
session['client'] = QuickBooks(
auth_client=auth_client,
refresh_token=auth_client.refresh_token,
company_id=realm_id,
)
print(session['user_info'])
return redirect('/')
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 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 setUp(self):
self.qb_client = QuickBooks(
sandbox=True,
consumer_key=os.environ.get('CONSUMER_KEY'),
consumer_secret=os.environ.get('CONSUMER_SECRET'),
access_token=os.environ.get('ACCESS_TOKEN'),
access_token_secret=os.environ.get('ACCESS_TOKEN_SECRET'),
company_id=os.environ.get('COMPANY_ID')
)
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)
def setUp(self):
self.qb_client = QuickBooks(
sandbox=True,
consumer_key=os.environ.get('CONSUMER_KEY'),
consumer_secret=os.environ.get('CONSUMER_SECRET'),
access_token=os.environ.get('ACCESS_TOKEN'),
access_token_secret=os.environ.get('ACCESS_TOKEN_SECRET'),
company_id=os.environ.get('COMPANY_ID'))
self.name = "Test Department {0}".format(
datetime.now().strftime('%d%H%M%S'))
def get_qbo_client(callback_url):
# https://developer.intuit.com/app/developer/qbo/docs/develop/authentication-and-authorization/oauth-2.0
redis_client = get_redis_client()
auth_client = get_qbo_auth_client(callback_url)
return QuickBooks(auth_client=auth_client,
refresh_token=redis_client.get('refresh_token'),
company_id=redis_client.get('realm_id'),
**QBO_DEFAULT_ARGS)
def refresh_session():
s = json.loads(get_secret())
auth_client = AuthClient(
client_id=s["client_id"],
client_secret=s["client_secret"],
redirect_uri=s["redirect_url"],
access_token=s["access_token"],
refresh_token=s["refresh_token"],
environment="production",
)
# caution! invalid requests return {"error":"invalid_grant"} quietly
auth_client.refresh()
s["access_token"] = auth_client.access_token
s["refresh_token"] = auth_client.refresh_token
put_secret(json.dumps(s))
QuickBooks.enable_global()
QuickBooks(auth_client=auth_client, company_id="1401432085")
return auth_client
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 setUp(self):
self.session_manager = Oauth1SessionManager(
sandbox=True,
consumer_key=os.environ.get('CONSUMER_KEY'),
consumer_secret=os.environ.get('CONSUMER_SECRET'),
access_token=os.environ.get('ACCESS_TOKEN'),
access_token_secret=os.environ.get('ACCESS_TOKEN_SECRET'),
)
self.qb_client = QuickBooks(session_manager=self.session_manager,
sandbox=True,
company_id=os.environ.get('COMPANY_ID'))
self.customer = Customer.all(max_results=1, qb=self.qb_client)[0]
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 setUp(self):
self.qb_client = QuickBooks(
sandbox=True,
consumer_key=os.environ.get('CONSUMER_KEY'),
consumer_secret=os.environ.get('CONSUMER_SECRET'),
access_token=os.environ.get('ACCESS_TOKEN'),
access_token_secret=os.environ.get('ACCESS_TOKEN_SECRET'),
company_id=os.environ.get('COMPANY_ID'))
self.title = "Mr"
self.given_name = "James"
self.middle_name = "B"
self.family_name = "King"
self.suffix = "Jr"
self.fully_qualified_name = datetime.now().strftime('%d%H%M%S')
self.company_name = datetime.now().strftime('%d%H%M%S')
self.display_name = datetime.now().strftime('%d%H%M%S')
def create_qbc():
refresh_token = pickle.load( open( "refresh.token", "rb" ) )
realm_id = pickle.load( open( "realm.id", "rb" ) )
auth_client = AuthClient(
cfg.qbo['QBO_CLIENT_ID'],
cfg.qbo['QBO_CLIENT_SECRET'],
"https://tdasu.pagekite.me/redirect",
environment="production"
)
client = QuickBooks(
auth_client=auth_client,
refresh_token=refresh_token,
company_id=realm_id,
)
return client
def _create_client(self):
auth_client = AuthClient(
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
environment=ENVIRONMENT,
redirect_uri=
'https://developer.intuit.com/v2/OAuth2Playground/RedirectUrl',
)
# Refresh token endpoint
auth_client.refresh(refresh_token=REFRESH_TOKEN)
client = QuickBooks(auth_client=auth_client,
refresh_token=REFRESH_TOKEN,
company_id=COMPANY_ID,
minorversion=54)
return client
def get_qbo_client(user, company):
db = boto3.resource('dynamodb')
table = db.Table(TABLE)
token = get_user(user, company)['qbo_refresh_token']
auth_client = AuthClient(CLIENT_KEY, CLIENT_SECRET, REDIRECT_URI, QBO_ENV)
auth_client.refresh(refresh_token=token)
client = QuickBooks(auth_client=auth_client,
refresh_token=auth_client.refresh_token,
environment=QBO_ENV,
company_id=company)
response = table.update_item(
Key={
'company': company,
'user': user
},
UpdateExpression="set #attr = :token",
ExpressionAttributeValues={':token': auth_client.refresh_token},
ExpressionAttributeNames={'#attr': 'qbo_refresh_token'})
return client
def get_qbo_context():
fc = FinanceConfig.load()
qbo_ensure_access_token()
q = QuickBooks(
auth_client=auth_client(),
refresh_token=fc.qboRefreshToken,
company_id=fc.qboRealmId,
minorversion=41,
)
this_report = qbo_cached_profit_loss_report(q, fc, MACRO_THIS_YEAR)
# last_report = qbo_cached_profit_loss_report(q, fc, MACRO_LAST_YEAR)
return {
'this_report': this_report,
# 'last_report': last_report,
'this_wg': wg_summary(this_report),
'this_type': type_summary(this_report),
# 'last_wg': wg_summary(last_report)
}
def authenticate_to_quickbooks():
print("authorizing to Quickbooks...")
auth_client = AuthClient(
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
environment=ENVIRONMENT,
redirect_uri='https://developer.intuit.com/v2/OAuth2Playground/RedirectUrl',
)
#url = auth_client.get_authorization_url(scopes=[Scopes.ACCOUNTING])
print("finished authorizing to Quickbooks...")
try:
client = QuickBooks(
auth_client=auth_client,
refresh_token=REFRESH_TOKEN,
company_id=COMPANY_ID,
)
print('finished connecting to Quickbooks...')
return client
except AuthClientError as e:
logging.error("Cannot connect to quickbooks: Error [{}]".format(e.content))
def test_valid_object_name(self):
obj = RefundReceipt()
client = QuickBooks()
result = client.isvalid_object_name(obj.qbo_object_name)
self.assertTrue(result)
def test_valid_object_name(self):
obj = CreditMemo()
client = QuickBooks()
result = client.isvalid_object_name(obj.qbo_object_name)
self.assertTrue(result)
from quickbooks import QuickBooks
from collections import OrderedDict
qb = QuickBooks()
# results1 = qb.call('BillQueryRq', {
# 'IncludeLineItems': 1,
# }, saveXML=True)
results2 = qb.call('BillAddRq', {
'BillAdd': OrderedDict([
('VendorRef', {
'FullName': 'Patton Hardware Supplies',
}),
('ExpenseLineAdd', {
'AccountRef': {
'FullName': 'Utilities:Telephone',
},
'Amount': '100.00',
}),
]),
}, saveXML=True)
results3 = qb.call('BillModRq', {
'BillMod': OrderedDict([
('TxnID', results2[0]['TxnID']),
('EditSequence', results2[0]['EditSequence']),
('TxnDate', '2011-01-01'),
('ExpenseLineMod', {
'TxnLineID': results2[0]['ExpenseLineRet']['TxnLineID'],
'Amount': '99.99',
}),
]),
}, saveXML=True)
from test7 import Inteum
from quickbooks import QuickBooks
from parameters import INTEUM_DSN, QUICKBOOKS_APPLICATION_NAME
# Load technologies from Inteum
inteum = Inteum(INTEUM_DSN)
allTechnologies = inteum.get_technologies()
# Load technologies from QuickBooks
quickbooks = QuickBooks(applicationName=QUICKBOOKS_APPLICATION_NAME)
oldTechnologies = []
for result in quickbooks.call('CustomerQueryRq', {}):
customerName = result.get('Name')
technologyCase, separator, technologyTitle = customerName.partition('-')
oldTechnologies.append({
'case': technologyCase.strip(),
'title': technologyTitle.strip(),
})
newTechologies = []
for oneTechnology in allTechnologies:
for oldTechnology in oldTechnologies:
if oneTechnology['case'] != oldTechnology['case']:
continue
if oneTechnology['title'] != oldTechnology['title']:
print 'MISMATCH'
print oneTechnology
print oldTechnology
continue
else:
def run(self):
# try:
self.show_text('Connecting to Inteum... ')
inteum = Inteum(INTEUM_DSN)
self.show_text('OK\n')
self.show_text('Loading technologies... ')
technologies = inteum.get_technologies()
self.show_text('%s\n' % len(technologies))
self.show_text('Loading patents... ')
patents = inteum.get_patents()
self.show_text('%s\n' % len(patents))
self.show_text('Loading patentTypes... ')
patentTypes = inteum.get_patentTypes()
self.show_text('%s\n' % len(patentTypes))
self.show_text('Loading lawFirms... ')
lawFirms = inteum.get_lawFirms()
self.show_text('%s\n' % len(lawFirms))
self.show_text('Loading countries... ')
countries = inteum.get_countries()
self.show_text('%s\n' % len(countries))
self.show_text('Loading expenses from spreadsheet... ')
qbr = self.module(technologies, patents, patentTypes, lawFirms, countries)
lawFirmExpenses = qbr.load_expenses(self.filePath)
self.show_text('%s\n' % len(lawFirmExpenses))
self.show_text('Connecting to QuickBooks... ')
qb = QuickBooks(applicationName=QUICKBOOKS_APPLICATION_NAME)
self.show_text('OK\n')
self.show_text('Updating vendors in QuickBooks using lawFirms from Inteum...\n')
qb.synchronize(lawFirms, 'Vendor', dict(
equal=qbr.equal_lawFirm,
parse_result=qbr.parse_vendor,
update_result=qbr.format_vendor,
format_result=qbr.format_vendor,
# expand_results=
# collapse_packs=
prompt_update=self.prompt_update,
prompt_save=self.prompt_save,
show_parse_error=self.show_error,
show_format_error=self.show_error,
summarize_candidatePacks=self.summarize_candidatePacks,
summarize_mismatches=self.summarize_mismatches,
summarize_newPacks=self.summarize_newPacks,
))
self.show_text('Updating customers in QuickBooks using technologies from Inteum...\n')
qb.synchronize(technologies, 'Customer', dict(
equal=qbr.equal_technology,
parse_result=qbr.parse_customer,
update_result=qbr.format_customer,
format_result=qbr.format_customer,
# expand_results=
# collapse_packs=
prompt_update=self.prompt_update,
prompt_save=self.prompt_save,
show_parse_error=self.show_error,
show_format_error=self.show_error,
summarize_candidatePacks=self.summarize_candidatePacks,
summarize_mismatches=self.summarize_mismatches,
summarize_newPacks=self.summarize_newPacks,
))
self.show_text('Updating jobs in QuickBooks using patents from Inteum...\n')
qb.synchronize(patents, 'Customer', dict(
equal=qbr.equal_patent,
parse_result=qbr.parse_job,
update_result=qbr.format_job,
format_result=qbr.format_job,
# expand_results=
# collapse_packs=
prompt_update=self.prompt_update,
prompt_save=self.prompt_save,
show_parse_error=self.show_error,
show_format_error=self.show_error,
summarize_candidatePacks=self.summarize_candidatePacks,
summarize_mismatches=self.summarize_mismatches,
summarize_newPacks=self.summarize_newPacks,
))
self.show_text('Updating expense accounts in QuickBooks...\n')
qb.synchronize([{'name': '6100 - Patent Related Expenses'}], 'Account', dict(
equal=lambda account1, account2: account1['name'].lower() == account2['name'].lower(),
parse_result=lambda result: {'name': result['FullName']},
# update_result=,
format_result=lambda account, show_format_error: OrderedDict([('Name', account['name']), ('AccountType', 'Expense')]),
# expand_results=,
# collapse_packs=,
# prompt_update=,
prompt_save=self.prompt_save,
show_parse_error=self.show_error,
show_format_error=self.show_error,
summarize_candidatePacks=self.summarize_candidatePacks,
summarize_mismatches=self.summarize_mismatches,
summarize_newPacks=self.summarize_newPacks,
))
self.show_text('Updating expenses in QuickBooks using expenses from spreadsheet...\n')
qb.synchronize(lawFirmExpenses, 'Bill', dict(
equal=qbr.equal_expense,
parse_result=qbr.parse_bill,
update_result=qbr.update_bill,
format_result=qbr.format_bill,
expand_results=qbr.expand_bills,
collapse_packs=qbr.collapse_expenses,
prompt_update=self.prompt_update,
prompt_save=self.prompt_save,
show_parse_error=self.show_error,
show_format_error=self.show_error,
summarize_candidatePacks=self.summarize_candidatePacks,
summarize_mismatches=self.summarize_mismatches,
summarize_newPacks=self.summarize_newPacks,
), {'IncludeLineItems': 1})
def test_valid_object_name(self):
obj = PaymentMethod()
client = QuickBooks()
result = client.isvalid_object_name(obj.qbo_object_name)
self.assertTrue(result)
def test_valid_object_name(self):
obj = Customer()
client = QuickBooks()
result = client.isvalid_object_name(obj.qbo_object_name)
self.assertTrue(result)
def test_valid_object_name(self):
obj = TimeActivity()
client = QuickBooks()
result = client.isvalid_object_name(obj.qbo_object_name)
self.assertTrue(result)
def test_valid_object_name(self):
obj = VendorCredit()
client = QuickBooks()
result = client.isvalid_object_name(obj.qbo_object_name)
self.assertTrue(result)
def test_valid_object_name(self):
obj = JournalEntry()
client = QuickBooks()
result = client.isvalid_object_name(obj.qbo_object_name)
self.assertTrue(result)
def test_valid_object_name(self):
account = Account()
client = QuickBooks()
result = client.isvalid_object_name(account.qbo_object_name)
self.assertTrue(result)
def test_valid_object_name(self):
obj = TimeActivity()
client = QuickBooks()
result = client.isvalid_object_name(obj.qbo_object_name)
self.assertTrue(result)
def test_valid_object_name(self):
attachable = Attachable()
client = QuickBooks()
result = client.isvalid_object_name(attachable.qbo_object_name)
self.assertTrue(result)
