def post(self, request, pk, *args, **kwargs): """ Parses the income statement and balance sheet sheet request, sent in the form of: {"IncomeStatement": [{ "Period": "2016-01", "Account": "Value"},{..}] } """ try: company = AccountsUtils.get_company(pk) try: entries, error_tags = AccountingUtils.parse_statement(request, company, request.data, FinancialStatementEntry.INCOME_STATEMENT) FinancialStatementEntry.objects.bulk_create(entries) except Exception as e: error = ["%s" % e] return Utils.dispatch_failure(request, 'DATA_PARSING_ISSUE', error) serializer = FinancialStatementEntrySerializer(entries, many=True) if len(serializer.data) > 0: return Utils.dispatch_success(request, serializer.data) return Utils.dispatch_success(request, 'NO_DATA_CHANGES') except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def connect(self, request, company): """ Connects a company to Xero company must be included in the querystring /?company=<id> """ try: secret_keys = Utils.get_access_keys(company) consumer_key = secret_keys.client_id consumer_secret = secret_keys.client_secret global credentials call_back_uri = settings.XERO_CALL_BACK_URI + "/" + company # call_back_url = 'http://localhost/oauth' if AccountingConfiguration.PRIVATE == secret_keys.type: credentials = PrivateCredentials(consumer_key=consumer_key,rsa_key=consumer_secret) OAUTH_PERSISTENT_SERVER_STORAGE.update({'consumer_key':credentials.consumer_key}) OAUTH_PERSISTENT_SERVER_STORAGE.update({'rsa_key':credentials.rsa_key}) url = call_back_uri else: credentials = PublicCredentials(consumer_key, consumer_secret, callback_uri=call_back_uri) # Save generated credentials details to persistent storage for key, value in credentials.state.items(): OAUTH_PERSISTENT_SERVER_STORAGE.update({key: value}) LoginInfo.objects.create(company_id=company, status=LoginInfo.IN_PROGRESS, created=timezone.now()) url = credentials.url except Exception as e: auth_cancel_url = settings.QBO_AUTH_CANCEL_URL Utils.send_company_misconfig(company,e) return redirect(auth_cancel_url + '/error') return Utils.redirect_response(url)
def connect(self, request, company_id): """ Connects a company to quickbooks company must be included in the querystring /?company=<id> :param company_id: :return: Redirect url of QuickBook """ try: if not getDiscoveryDocument: # todo: need to clarify this scenario occurs or not and handle correct redirct urls auth_cancel_url = settings.QBO_AUTH_CANCEL_URL return redirect(auth_cancel_url) url = getDiscoveryDocument.auth_endpoint configuration = Utils.get_access_keys(company_id) client_id = configuration.client_id params = { 'scope': settings.ACCOUNTING_SCOPE, 'redirect_uri': settings.REDIRECT_URI, 'response_type': 'code', 'state': company_id, 'client_id': client_id } url += '?' + urllib.urlencode(params) LoginInfo.objects.create(company_id=company_id, status=LoginInfo.IN_PROGRESS, created=timezone.now()) return redirect(url) except Exception as e: auth_cancel_url = settings.QBO_AUTH_CANCEL_URL Utils.send_company_misconfig(company_id, e) return redirect(auth_cancel_url + '/error')
def trail_balance(self, pk, request): """ Get the trail balance profile from Quick Books :param pk: company: Company ID :return: Response of trail balance """ try: meta = CompanyMeta.objects.filter(company_id=pk).first() if meta.monthly_reporting_current_period: st = time.time() # this will grab the trial balance for the companymeta.monthly_reporting_current_period # plus 23 more months worth of history. job = group( trial_balance_for_period.s(pk, i) for i in range(0, 23)) result = job.apply_async() else: return Utils.dispatch_failure( request, 'MISSING_MONTHLY_REPORTING_CURRENT_PERIOD') # note: this bit of code basically turns this into a synchronous call, this is intended behaviour for now # todo: phase 2 we need to add sockets for better communication with UI while not result.ready(): continue print('##### CELERY get TB now takes {:.2f}s'.format(time.time() - st)) return Utils.dispatch_success(request, 'TRIAL_BALANCE_RECEIVED_SUCCESS') except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def get(self, request, pk, report_identifier): """ Gets a Company's Questionnaire answers for the requested period If called with no period specified, it simply returns a blank set of questions. The functionality supports the UI which dynamically displays the questions returned by the server. """ try: response = None response_status = status.HTTP_200_OK context = {'request': request, 'company': pk, 'period': report_identifier} print('############### BEFORE INT COMPARISON') # todo: logic needs to be cleaned up. questions and has_answers have overlapping functionality that can be # simplified questions = ReportingUtils.get_questionnaire_objects(pk, report_identifier) has_answers = ReportingUtils.has_answers_for_period(pk, report_identifier) if questions and has_answers: # return Q n A for requested period. serializer = QuestionWithAnswerSerializer(questions, many=True, context=context) if len(serializer.data) > 0: return Utils.dispatch_success(request,serializer.data) return Utils.dispatch_success(request,'NO_ANSWER_FOUND') return Utils.dispatch_success (request, 'DATA_NOT_FOUND') except Exception as e: return Utils.dispatch_failure(request,'INTERNAL_SERVER_ERROR')
def get(self, request, pk): """ Gets a Company's Questionnaire answers """ try: response = None response_status = status.HTTP_200_OK context = {'request': request, 'company': pk, } # get an empty set of questions qs1 = Question.objects.filter(Q(common_to_all_companies=True, show_on_ui=True) | Q(common_to_all_companies=False,show_on_ui=True,company=pk))\ .all() qs1 = ReportingUtils.sanitize_next_questions(qs1) serializer = QuestionWithAnswerSerializer(qs1, many=True, context=context) if len (serializer.data) > 0: return Utils.dispatch_success (request,serializer.data) return Utils.dispatch_success (request,'NO_ANSWER_FOUND') except Exception as e: return Utils.dispatch_failure(request,'INTERNAL_SERVER_ERROR')
def put(self, request, pk, report_identifier, *args, **kwargs): """ Updates a Company's Monthly Report instance Monthly Report Period or Monthly Report ID """ try: company = AccountsUtils.get_company(pk) if '-' in report_identifier: monthly_report = ReportingUtils.get_monthly_report(pk=pk, period=report_identifier) else: monthly_report = ReportingUtils.get_monthly_report(pk=pk, report_id=report_identifier) response_status = status.HTTP_200_OK # default to OK and override if not if monthly_report: data = request.data data['company'] = company.id serializer = MonthlyReportSerializer(monthly_report, data=data, context={'request': request, 'company_id': pk}, partial=True) if serializer.is_valid(): serializer.save() return Utils.dispatch_success(request,serializer.data) else: return Utils.dispatch_failure (request,'VALIDATION_ERROR',serializer.errors) return Utils.dispatch_failure(request,'MONTHLY_REPORT_NOT_FOUND') except Exception as e: return Utils.dispatch_failure (request,'INTERNAL_SERVER_ERROR')
def trial_balance_for_period(pk, period_offset): cm = CompanyMeta.objects.filter(company_id=pk).first() cm.save() company = AccountsUtils.get_company(pk) st = time.time() credentials = AccountingUtils.get_credentials_by_company(company) if not credentials: return if not cm.monthly_reporting_current_period: return if company.accounting_type.lower() == Company.QUICKBOOKS.lower(): period = cm.monthly_reporting_current_period - relativedelta( months=+period_offset, day=31) # print('##### Getting TRIAL BALANCE for period ', period) query = '?start_date=' + period.strftime( '%Y-%m-1') + '&end_date=' + period.strftime('%Y-%m-%d') # print('####### QBO TB QUERY ', query) # for query in query_list: trial_balance_response, status_code = Utils.get_trial_balance( credentials.accessToken, credentials.realmId, query) if status_code >= 400: bearer = Utils.get_bearer_token_from_refresh_token( credentials.refreshToken) new_credentials = AccountingUtils.updateAccountingSession( company, bearer.accessToken, bearer.refreshToken, credentials.realmId) trial_balance_response, status_code = Utils.get_trial_balance( new_credentials.accessToken, new_credentials.realmId, query) if status_code >= 400: return from .third_party.quickbooks import QuickBooks entries = QuickBooks.save_trial_balance(company, trial_balance_response) TrialBalance.objects.bulk_create(entries) if company.accounting_type.lower() == Company.XERO.lower(): period = cm.monthly_reporting_current_period - relativedelta( months=+period_offset, day=31) # params = {'fromDate': str(period.strftime('%Y-%m-01')), 'toDate': str(period.strftime('%Y-%m-%d'))} params = {'date': str(period.strftime('%Y-%m-%d'))} auth = Utils.get_xero_auth(pk) credentials = Utils.get_xero_credentials(pk, **auth) xero = Xero(credentials) trialbalance = xero.reports.get('TrialBalance', params=params) XeroAccountings.save_trial_balance(company, trialbalance[0]) # print('{:.2f}s Elapsed'.format(time.time() - st)) # print('Took {:.2f}s Total'.format(time.time() - st)) cm.trialbalance_last_refresh_date = datetime.datetime.now() cm.trialbalance_dl_complete = True cm.save() return
def auth_code_handler(self, request, pk=None): """ Handles the authentication Code from quickbooks redirect :param pk: Company ID :param request: :return: """ try: state = request.GET.get('state', None) error = request.GET.get('error', None) auth_cancel_url = settings.QBO_AUTH_CANCEL_URL print('############ auth code handler state ', state) if error == 'access_denied': print('############ auth code handerl access deined ', error) return redirect(auth_cancel_url) if state is None: return redirect(auth_cancel_url) auth_code = request.GET.get('code', None) print('############ auth code handerl code ', auth_code) if auth_code is None: return redirect(auth_cancel_url) company = AccountsUtils.get_company(state) bearer = Utils.get_bearer_token(auth_code) realmId = request.GET.get('realmId', None) AccountingUtils.updateAccountingSession(company, bearer.accessToken, bearer.refreshToken, realmId) qb_status = LoginInfo.objects.filter( company=company, status=LoginInfo.IN_PROGRESS, created__range=[ timezone.now() - datetime.timedelta(minutes=10), timezone.now() ]).first() qb_status.status = LoginInfo.COMPLETED # todo: change this env variable for production #qbo_auth_redirect_url = os.environ.get('QBO_AUTH_REDIRECT_URL') auth_redirect_url = settings.QBO_AUTH_REDIRECT_URL #auth_redirect_url = os.environ.get ('QBO_AUTH_REDIRECT_URL','http://ec2-52-207-28-114.compute-1.amazonaws.com/IX/coa-match/quickbooks') return redirect(auth_redirect_url) #return Utils.dispatch_success(request,"successfully authenticated") except Exception as e: # todo: need to clarify this scenario occurs or not and handle correct redirect urls auth_cancel_url = settings.QBO_AUTH_CANCEL_URL Utils.send_company_misconfig(pk, e) return redirect(auth_cancel_url + '/error')
def post(self, request, pk, *args, **kwargs): try: company = AccountsUtils.get_company(pk) # print('CoAMap POST - request.data ', request.data) updated_maps = AccountingUtils.set_coa_map(company, request.data) serializer = UpdatedCoAMapSerializer(updated_maps, many=True) if len(serializer.data): return Utils.dispatch_success(request, serializer.data) return Utils.dispatch_success(request, "NO_DATA_CHANGES") except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def get(self, request, *args, **kwargs): try: company_id = request.GET.get('company', None) # Check company is exists is_valid_company, message = Utils.check_company_exists(company_id) if not is_valid_company: return Utils.dispatch_failure(request, "RESOURCE_NOT_FOUND") return Accounting().get_instance_by_id(company_id).connect(request, company_id) except KeyError: return redirect(request.META["HTTP_REFERRER"]) except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def get(self, request, pk, *args, **kwargs): """ Lists all monthly reports for the specified companies """ try: self.queryset = MonthlyReport.objects.filter(company=pk).order_by('period_ending') if len (self.queryset) == 0: return Utils.dispatch_success(request,'DATA_NOT_FOUND') return super(MonthlyReportList, self).get(request) except Exception: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def delete(self, request, pk, *args, **kwargs): try: if self.request.user.is_superuser: company = AccountsUtils.get_company(pk) if TrialBalance.objects.filter(company=company).count(): TrialBalance.objects.filter(company=company).delete() return Utils.dispatch_success(request, 'DELETED_SUCCESSFULLY') else: return Utils.dispatch_failure(request, "OBJECT_RESOURCE_NOT_FOUND") return Utils.dispatch_failure(request, 'UNAUTHORIZED_ACCESS') except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def put(self, request, pk, *args, **kwargs): """ Updates verified by user in CoAMap for a company in the database """ try: company = AccountsUtils.get_company(pk) coamap = CoAMap.objects.filter(company_id=company) for entry in coamap: entry.verified_by_user = False entry.save() return Utils.dispatch_success(request, 'COAMAP_UPDATED_SUCCESSFULLY') except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def get_instance_by_id(self, company_id): """ This Wrapper method returns the object of the class for using in accounting system :param accounting_type:Name of the accounting system :return: Object of the accounting system to be accessed """ accounting_type = Utils.capitalize( Utils.get_accounting_type(company_id)) if accounting_type == Company.QUICKBOOKS: return QuickBooks() elif accounting_type == Company.XERO: return XeroAccountings() elif accounting_type == Company.SAGE: return SageAccountings()
def trail_balance(self, id, request): """ Get Trail Balance From Database :param id: Company Id :return: Response """ try: entries = TrialBalance.objects.filter(company=id) serializer = TrialBalanceSerializer(entries, many=True) if len(serializer.data) > 0: return Utils.dispatch_success(request, serializer.data) return Utils.dispatch_success(request, 'NO_DATA_CHANGES') except Exception: return Utils.dispatch_failure(request, "INTERNAL_SERVER_ERROR")
def delete(self, request, pk, *args, **kwargs): try: if self.request.user.is_superuser: company = AccountsUtils.get_company(pk) if FinancialStatementEntry.objects.filter(company=company, statement_type=FinancialStatementEntry.INCOME_STATEMENT, ).count(): FinancialStatementEntry.objects.filter(company=company, statement_type=FinancialStatementEntry.INCOME_STATEMENT, ).delete() return Utils.dispatch_success(request, 'DELETED_SUCCESSFULLY') return Utils.dispatch_success(request, "DATA_NOT_FOUND") return Utils.dispatch_failure(request, 'UNAUTHORIZED_ACCESS') except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def get(self, request, pk, report_identifier, *args, **kwargs): """ Gets a Company's Monthly Report instance by Monthly Report Period or Monthly Report ID """ try: if '-' in report_identifier: monthly_report = ReportingUtils.get_monthly_report(pk=pk, period=report_identifier) else: monthly_report = ReportingUtils.get_monthly_report(pk=pk, report_id=report_identifier) if monthly_report: serializer = MonthlyReportSerializer(monthly_report, context={'request': request, 'company_id': pk}) return Utils.dispatch_success(request,serializer.data) return Utils.dispatch_failure(request,'MONTHLY_REPORT_NOT_FOUND') except Exception as e: return Utils.dispatch_failure (request,'INTERNAL_SERVER_ERROR')
def has_permission(self, request, view): try: split_url = request.META.get('PATH_INFO').split("/") if split_url[3] == "docs": return request.user.is_authenticated() if len(view.kwargs) == 0 or split_url[3] != "company": if request.user.is_superuser: return request.user and request.user.is_authenticated() else: raise UnauthorizedAccess is_valid_company, message = Utils.check_company_exists(view.kwargs["pk"]) if not is_valid_company: raise ResourceNotFound if request.user.is_superuser: return request.user and request.user.is_authenticated() else: return ((request.user.is_superuser or request.user.company.id == int( view.kwargs["pk"])) and request.user.is_authenticated()) except APIException as err: raise err
def get(self, request, pk, *args, **kwargs): """ Check to see if the Accounting System token is still valid for the company """ try: return Accounting().get_instance_by_id(pk).is_token_valid(pk, request) except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def post(self, request, pk, *args, **kwargs): """ Starts a new monthly report for the current reporting period, and moves next period ahead by 1 month to prepare for the next time. Will not create one that already exists, or create another one until the previous one is completed, this is a business rule. """ try: company = AccountsUtils.get_company(pk) response_status = status.HTTP_200_OK response = '' meta = CompanyMeta.objects.filter(company_id=pk).first() current_period = meta.monthly_reporting_current_period next_period = meta.monthly_reporting_next_period if current_period is None: Utils.send_company_meta(request.user,"PERIOD") return Utils.dispatch_failure(request,'MISSING_MONTHLY_REPORTING_CURRENT_PERIOD') try: # does one exist for the current period report = MonthlyReport.objects.filter(company=company, period_ending=current_period).first() print('######## CURR AND NEXT - start as: c: ', current_period, ' n: ', next_period, ' rpt: ', report) except Exception as e: error = ["%s" % e] return Utils.dispatch_failure (request,'DATA_PARSING_ISSUE', error) # if it doesn't exist, or if the previous one has been completed, then it's ok to create a new one if not report or report.status == 'Complete': # todo: Due date is not relevant, remove it. We allow them to report any time after the end of the current # during initial setup, we do not advance the reporting dates. There is no initial setup for Form Entry # aka manual reporting if not meta.is_initial_setup: print('#### moving period forward for new monthly report') current_period = next_period next_period = next_period + relativedelta(months=+1, day=31) meta.monthly_reporting_current_period = current_period meta.monthly_reporting_next_period = next_period meta.monthly_reporting_current_period_status = 'IN_PROGRESS' meta.save() print('######## CURR AND NEXT - not initial setup, after move forward ', current_period, next_period) print('#### creating new monthly report for current period = ', meta.monthly_reporting_current_period) report = MonthlyReport(status='In Progress', company_id=pk, period_ending=current_period) report.save() response = serializers.serialize('json', [report, ]) # return response return Utils.dispatch_success(request,[response]) else: # was using HTTP_304_NOT_MODIFIED, but when this status is returned the JSON message is null which causes # problems for the UI # 409 causes the UI to stop processing because it thinks theres an error, but there isn't one. # so changing to 200 OK instead since it's OK to move forward # response_status = status.HTTP_409_CONFLICT return Utils.dispatch_success(request,'MONTHLY_REPORT_ALREADY_EXISTS_WITH_INPROGRESS') except Exception as e: return Utils.dispatch_failure (request,'INTERNAL_SERVER_ERROR')
def get(self, request, pk, *args, **kwargs): """ Gets the Balance Sheet Financial Statement Entries from the database Range can be specified by adding ?start_date=YYYY-MM-DD&end_date=YYYY-MM-DD No date params will return all entries for the specified company. end_date param only will provide data for that specific period. A start_date without an end_date, it will cause an error. """ try: company = AccountsUtils.get_company(pk) # todo: query variable is never used, and appears to be unncessary query, dates = Utils.validate_query(request, dateformat=True) # todo: figure out why order_by isn't workin on these query_sets, ordering added to model as workaround if not dates: print('########### not dates') queryset = FinancialStatementEntry.objects.filter(company=company, statement_type=FinancialStatementEntry.BALANCE_SHEET) else: if dates[0] == 'ERROR': return Utils.dispatch_failure(request, dates[1]) elif len(dates) == 2: queryset = FinancialStatementEntry.objects.filter(company=company, period_ending__range=(dates[0], dates[1]), statement_type=FinancialStatementEntry.BALANCE_SHEET, ) elif len(dates) == 1: print(dates) queryset = FinancialStatementEntry.objects.filter(company=company, period_ending=dates[0], statement_type=FinancialStatementEntry.BALANCE_SHEET, ) else: print(dates) queryset = FinancialStatementEntry.objects.filter(company=company, statement_type=FinancialStatementEntry.BALANCE_SHEET) if queryset: serializer = FinancialStatementEntrySerializer(queryset, many=True) return Utils.dispatch_success(request, serializer.data) return Utils.dispatch_success(request, 'DATA_NOT_FOUND') except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def get(self, request, pk, *args, **kwargs): """ Gets the trial balance from online and writes to database """ # Check company is exists try: return Accounting().get_instance_by_id(pk).trail_balance(pk, request) except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def get(self, request, pk, *args, **kwargs): """ Gets the Income Statement Financial Statement Entries from the database Range can be specified by adding ?start_date=YYYY-MM-DD&end_date=YYYY-MM-DD No date params will return all entries for the specified company. end_date param only will provide data for that specific period. A start_date without an end_date, it will cause an error. """ try: company = AccountsUtils.get_company(pk) query, dates = Utils.validate_query(request, dateformat=True) if not dates: queryset = FinancialStatementEntry.objects.filter(company=company, statement_type=FinancialStatementEntry.INCOME_STATEMENT) else: if dates[0] == 'ERROR': return Utils.dispatch_failure(request, dates[1]) elif len(dates) == 2: queryset = FinancialStatementEntry.objects.filter(company=company, period_ending__range=(dates[0], dates[1]), statement_type=FinancialStatementEntry.INCOME_STATEMENT, ) elif len(dates) == 1: queryset = FinancialStatementEntry.objects.filter(company=company, period_ending=dates[0], statement_type=FinancialStatementEntry.INCOME_STATEMENT, ) else: queryset = FinancialStatementEntry.objects.filter(company=company, statement_type=FinancialStatementEntry.INCOME_STATEMENT) queryset = queryset.order_by('value') if queryset: serializer = FinancialStatementEntrySerializer(queryset, many=True) return Utils.dispatch_success(request, serializer.data) return Utils.dispatch_success(request, 'DATA_NOT_FOUND') except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def save_trial_balance(company, response): """ Parses the quickbooks JSON Response of the trial balance follows the format provided here https://developer.intuit.com/docs/api/accounting/trial%20balance :param company: :param response: :return: trial_balances """ period = Utils.format_period(response["Header"]["EndPeriod"]) currency = response["Header"]["Currency"] headers = [ column["ColTitle"] if column["ColTitle"] != "" else column["ColType"] for column in response["Columns"]["Column"] ] entries = [] if response["Rows"]: for row in response["Rows"]["Row"]: d = {} if 'ColData' in row: for i in range(len(row["ColData"])): d[headers[i]] = row["ColData"][i]["value"] if i == 0: d['id'] = row["ColData"][i]["id"] d['Debit'] = float(d["Debit"]) if d["Debit"] != "" else 0 d['Credit'] = float( d["Credit"]) if d["Credit"] != "" else 0 rows_affected = TrialBalance.objects.filter( company=company, period=period, gl_account_id=d["id"]).update( debit=d["Debit"], credit=d["Credit"], gl_account_name=d["Account"]) if rows_affected == 0: entry = TrialBalance(company=company, gl_account_name=d["Account"], debit=d["Debit"], credit=d["Credit"], period=period, currency=currency, gl_account_id=d["id"]) entries.append(entry) else: print("Dont process the row") #TrialBalance.objects.bulk_create(entries) return entries
def delete(self, request,pk, report_identifier, *args, **kwargs): """ Updates a Company's Monthly Report instance Monthly Report Period or Monthly Report ID """ try: # TODO: Can you delete monthly reports? pls confirm if self.request.user.is_superuser: if '-' in report_identifier: monthly_report = ReportingUtils.get_monthly_report(pk=pk, period=report_identifier) else: monthly_report = ReportingUtils.get_monthly_report(pk=pk, report_id=report_identifier) if monthly_report: monthly_report.delete() return Utils.dispatch_success(request,'DELETED_SUCCESSFULLY') return Utils.dispatch_failure(request, 'MONTHLY_REPORT_NOT_FOUND') return Utils.dispatch_failure(request,'UNAUTHORIZED_ACCESS') except Exception as e: return Utils.dispatch_failure (request,'INTERNAL_SERVER_ERROR')
def get(self, request, pk, *args, **kwargs): """ Gets the Chart of accounts from online and writes to database """ # Check company is exists try: return Accounting().get_instance_by_id(pk).chart_of_accounts(pk, request) except Exception as e: print(e) return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')
def disconnect(self, pk, request): """ Disconnect the QuickBooks :param pk: Company ID :return: Response """ company = AccountsUtils.get_company(pk) credentials = AccountingUtils.get_credentials_by_company(company) try: revoke_response = Utils.revoke_token(credentials.accessToken) if "Token is incorrect" in revoke_response: return Utils.dispatch_failure(request, "NO_TOKEN_AUTHENTICATION") return Utils.dispatch_success(request, "REVOKE_SUCCESSFULL") except Exception as e: print(e) return Utils.dispatch_failure(request, "NO_TOKEN_AUTHENTICATION")
def is_token_valid(self, pk, request): """ Check the validity of Token :param pk: Company ID :return: Response of validation """ try: company = AccountsUtils.get_company(pk) credentials = AccountingOauth2.objects.filter( company=company).first() if credentials: sample_response, status_code = Utils.get_company_info( credentials.accessToken, credentials.realmId) if status_code >= 400: bearer = get(credentials.refreshToken) new_credentials = AccountingUtils.updateAccountingSession( company, bearer.accessToken, bearer.refreshToken, credentials.realmId) sample_response, status_code = Utils.get_company_info( new_credentials.accessToken, new_credentials.realmId) if status_code >= 400: return Utils.dispatch_failure( request, 'NO_TOKEN_AUTHENTICATION') return Utils.dispatch_success(request, "AUTHENTICATED_SUCCESSFULLY") return Utils.dispatch_failure(request, 'NO_TOKEN_AUTHENTICATION') except Exception as e: return Utils.dispatch_failure(request, 'NO_TOKEN_AUTHENTICATION')
def get(self, request, pk, *args, **kwargs): """ Creates the CoAMap for a company from the CoA in the database """ try: company = AccountsUtils.get_company(pk) coa = CoA.objects.filter(company=company) remap = request.GET.get('remap', None) if coa: default_mappings = DefaultAccountTagMapping.objects.filter(software__iexact=company.accounting_type) if not default_mappings: return Utils.dispatch_failure(request, "OBJECT_RESOURCE_NOT_FOUND") # todo: make sure abstract financial statement entry tags are not getting processed in the CoA Mapping try: entries = AccountingUtils.create_coa_map(request, company, default_mappings, coa, remap) except Exception as e: error = ["%s" % e] return Utils.dispatch_failure(request, 'DATA_PARSING_ISSUE', error) if len(entries) > 0: serializer = CoAMapSerializer(entries, many=True) return Utils.dispatch_success(request, serializer.data) return Utils.dispatch_success(request, "NO_DATA_CHANGES") return Utils.dispatch_failure(request, "OBJECT_RESOURCE_NOT_FOUND") except Exception as e: return Utils.dispatch_failure(request, 'INTERNAL_SERVER_ERROR')