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): attachable = Attachable() client = QuickBooks() result = client.isvalid_object_name(attachable.qbo_object_name) self.assertTrue(result)