def login(): global platform if os.environ.get("ENVIRONMENT_MODE") == "sandbox": sdk = SDK(os.environ.get("CLIENT_ID_SB"), os.environ.get("CLIENT_SECRET_SB"), 'https://platform.devtest.ringcentral.com') platform = sdk.platform() platform.login(os.environ.get("USERNAME_SB"), '', os.environ.get("PASSWORD_SB")) else: sdk = SDK(os.environ.get("CLIENT_ID_PROD"), os.environ.get("CLIENT_SECRET_PROD"), 'https://platform.ringcentral.com') platform = sdk.platform() platform.login(os.environ.get("USERNAME_PROD"), '', os.environ.get("PASSWORD_PROD")) CreateMessageStoreReport()
def main(): sdk = SDK(APP_KEY, APP_SECRET, SERVER) platform = sdk.platform() platform.login(USERNAME, EXTENSION, PASSWORD) # Simple GET response = platform.get('/account/~/extension/~') user = response.json() user_id = str(user.id) print('User loaded ' + user.name + ' (' + user_id + ')') print('Headers ' + str(response.response().headers)) print(type(response.response()._content)) # Multipart response try: multipart_response = platform.get('/account/~/extension/' + user_id + ',' + user_id + '/presence').multipart() print 'Multipart 1\n' + str(multipart_response[0].json_dict()) print 'Multipart 2\n' + str(multipart_response[1].json_dict()) except ApiException as e: print 'Cannot load multipart' print 'URL ' + e.api_response().request().url print 'Response' + str(e.api_response().json())
def main(): sdk = SDK(APP_KEY, APP_SECRET, SERVER) platform = sdk.platform() platform.login(USERNAME, EXTENSION, PASSWORD) # Step 1. Get an answering rule ID answering_rules = platform.get( '/account/~/extension/~/answering-rule').json().records last_answer_rule_id = answering_rules[-1].id print 'Answering rule ID: ' + last_answer_rule_id # Step 2. Update greeting audio file binary = ('test.mp3', urllib.urlopen( 'https://freesound.org/data/previews/85/85785_14771-lq.mp3'). read(), 'audio/mpeg') builder = sdk.create_multipart_builder() builder.set_body({ 'type': 'Voicemail', 'answeringRule': { 'id': last_answer_rule_id } }) builder.add(binary) builder.set_multipart_mixed(True) request = builder.request('/account/~/extension/~/greeting') response = platform.send_request(request) print 'Updated greeting audio: ' + response.json().uri
def main(): sdk = SDK(APP_KEY, APP_SECRET, SERVER) platform = sdk.platform() platform.login(USERNAME, EXTENSION, PASSWORD) def on_message(msg): print(msg) def pubnub(): try: s = sdk.create_subscription() s.add_events(['/account/~/extension/~/message-store']) s.on(Events.notification, on_message) s.register() while True: sleep(0.1) except KeyboardInterrupt: print("Pubnub listener stopped...") p = Process(target=pubnub) try: p.start() except KeyboardInterrupt: p.terminate() print("Stopped by User") print("Wait for notification...")
def ring(config, recipient): RINGCENTRAL_CLIENTID = config["RINGCENTRAL_CLIENTID"] RINGCENTRAL_CLIENTSECRET = config["RINGCENTRAL_CLIENTSECRET"] RINGCENTRAL_SERVER = config["RINGCENTRAL_SERVER"] RINGCENTRAL_USERNAME = config["RINGCENTRAL_USERNAME"] RINGCENTRAL_PASSWORD = config["RINGCENTRAL_PASSWORD"] RINGCENTRAL_EXTENSION = config["RINGCENTRAL_EXTENSION"] print(json.dumps(config)) rcsdk = SDK(RINGCENTRAL_CLIENTID, RINGCENTRAL_CLIENTSECRET, RINGCENTRAL_SERVER) platform = rcsdk.platform() platform.login(RINGCENTRAL_USERNAME, RINGCENTRAL_EXTENSION, RINGCENTRAL_PASSWORD) resp = platform.post( '/restapi/v1.0/account/~/extension/~/ring-out', { 'from': { 'phoneNumber': RINGCENTRAL_USERNAME }, 'to': { 'phoneNumber': recipient }, 'playPrompt': False }) print(f"Call placed. Call status: {resp.json().status.callStatus}") print(resp.json_dict())
def sendSMS(): RECIPIENT = '16479958354' RINGCENTRAL_CLIENTID = 'ytNEYQCjS86w1BIYgIZNng' RINGCENTRAL_CLIENTSECRET = 'UU_Bm0yxT0SRaoQy3lSbggUozARI4lRe-6RNuuM1eWig' RINGCENTRAL_SERVER = 'https://platform.devtest.ringcentral.com' RINGCENTRAL_USERNAME = '******' RINGCENTRAL_PASSWORD = '******' RINGCENTRAL_EXTENSION = '101' rcsdk = SDK(RINGCENTRAL_CLIENTID, RINGCENTRAL_CLIENTSECRET, RINGCENTRAL_SERVER) platform = rcsdk.platform() platform.login(RINGCENTRAL_USERNAME, RINGCENTRAL_EXTENSION, RINGCENTRAL_PASSWORD) platform.post( '/restapi/v1.0/account/~/extension/~/sms', { 'from': { 'phoneNumber': RINGCENTRAL_USERNAME }, 'to': [{ 'phoneNumber': RECIPIENT }], 'text': 'Hey gurlllllll' })
def main(): sdk = SDK(APP_KEY, APP_SECRET, SERVER) platform = sdk.platform() platform.login(USERNAME, EXTENSION, PASSWORD) def getcustomfields(): response = platform.get('/account/~/custom-fields') custom_fields = response.json() try: for x in range(len(custom_fields.records)): print('Display Name- ' + custom_fields.records[x].displayName + ' id- ' +custom_fields.records[x].id + ' Category- '+custom_fields.records[x].category + '\n' ) #print(custom_fields.records) except ApiException as e: print("Error while fetching custom fields" + e) # This is to Fetch the custom Fields in an Account def createcustomfields(): #POST Body body ={ "category": "User", "displayName": "HRCODE-TEST3" } try: response = platform.post('/account/~/custom-fields', body) print("Custom Field Created") except ApiException as e: print("Error while creating custom fields" + e) # This is to Fetch the custom Fields in an Account def updatecustomfields(id): #POST Body body ={ "displayName": "HRCODE" } try: response = platform.put('/account/~/custom-fields/{}'.format(id), body) print(response.json().displayName) except ApiException as e: print("Error while creating custom fields" + e) def deletecustomfields(id): try: response = platform.delete('/account/~/custom-fields/{}'.format(id)) print("Deleted") print("Custom Field Deleted") except ApiException as e: print("Error while creating custom fields" + e)
def oauth2callback(): global rcsdk rcsdk = SDK(os.getenv("RC_CLIENT_ID"), os.getenv("RC_CLIENT_SECRET"), os.getenv("RC_SERVER_URL")) platform = rcsdk.platform() auth_code = request.values.get('code') platform.login('', '', '', auth_code, os.getenv("RC_REDIRECT_URL")) tokens = platform.auth().data() session['tokens'] = tokens return "Login successfully"
def send_sms(req): body = { 'from': { 'phoneNumber': '+19293141718' }, 'to': [{ 'phoneNumber': req['phone'] }], 'text': req['message'] } rcsdk = SDK('qQ68acHFT3GS2QnAMuHgiw', 'Pg9yu1F4QLiSWohD6UlFUA9zd1nIG-SDCtfhcjSJxiLg', 'https://platform.devtest.ringcentral.com') platform = rcsdk.platform() platform.login('+19293141718', '101', 'welcomeKK@2020') r = platform.post( f'/restapi/v1.0/account/' + accountId + '/extension/' + extensionId + '/sms', body) return {"statusCode": 201, "message": "Sms sent successfully"}
def main(): sdk = SDK(APP_KEY, APP_SECRET, SERVER) platform = sdk.platform() platform.login(USERNAME, EXTENSION, PASSWORD) # Step 1. Get MMS-enabled phone number phone_numbers = platform.get('/account/~/extension/~/phone-number', { 'perPage': 'max' }).json().records mms_number = None for phone_number in phone_numbers: if 'MmsSender' in phone_number.features: mms_number = phone_number.phoneNumber print('MMS Phone Number: ' + mms_number) # Step 2. Send MMS attachment = ( 'test.png', urllib.urlopen( 'https://developers.ringcentral.com/assets/images/ico_case_crm.png' ).read(), 'image/png') builder = sdk.create_multipart_builder() builder.set_body({ 'from': { 'phoneNumber': mms_number }, 'to': [{ 'phoneNumber': MOBILE }], 'text': 'MMS from Python' # this is optional }) builder.add(attachment) request = builder.request('/account/~/extension/~/sms') response = platform.send_request(request) print('Sent MMS: ' + response.json().uri)
def main(): sdk = SDK(APP_KEY, APP_SECRET, SERVER) platform = sdk.platform() platform.login(USERNAME, EXTENSION, PASSWORD) to_numbers = "1234567890" params = { 'from': { 'phoneNumber': USERNAME }, 'to': [{ 'phoneNumber': to_number }], 'text': "SMS message" } response = platform.post('/restapi/v1.0/account/~/extension/~/sms', params) print('Sent SMS: ' + response.json().uri)
def send_message(content): RECIPIENT = os.getenv('TARGET_PHONE_NUMBER') RINGCENTRAL_CLIENTID = os.getenv('RINGCENTRAL_CLIENTID') RINGCENTRAL_CLIENTSECRET = os.environ.get('RINGCENTRAL_CLIENTSECRET') RINGCENTRAL_SERVER = os.environ.get('RINGCENTRAL_SERVER') RINGCENTRAL_USERNAME = os.environ.get('RINGCENTRAL_USERNAME') RINGCENTRAL_PASSWORD = os.environ.get('RINGCENTRAL_PASSWORD') RINGCENTRAL_EXTENSION = os.environ.get('RINGCENTRAL_EXTENSION') rcsdk = SDK(RINGCENTRAL_CLIENTID, RINGCENTRAL_CLIENTSECRET, RINGCENTRAL_SERVER) platform = rcsdk.platform() platform.login(RINGCENTRAL_USERNAME, RINGCENTRAL_EXTENSION, RINGCENTRAL_PASSWORD) platform.post('/restapi/v1.0/account/~/extension/~/sms', { 'from' : { 'phoneNumber': RINGCENTRAL_USERNAME }, 'to' : [ {'phoneNumber': RECIPIENT} ], 'text' : content })
def sendSMSMessage(conn, toNumber, email, message): if os.getenv("ENVIRONMENT_MODE") == "sandbox": rcsdk = SDK(os.getenv("CLIENT_ID_SB"), os.getenv("CLIENT_SECRET_SB"), 'https://platform.devtest.ringcentral.com') username = os.getenv("USERNAME_SB") pwd = os.getenv("PASSWORD_SB") else: rcsdk = SDK(os.getenv("CLIENT_ID_PROD"), os.getenv("CLIENT_SECRET_PROD"), 'https://platform.ringcentral.com') username = os.getenv("USERNAME_PROD") pwd = os.getenv("PASSWORD_PROD") platform = rcsdk.platform() try: platform.login(username, '', pwd) code = str(generateRandomCode(6)) params = { 'from': { 'phoneNumber': username }, 'to': [{ 'phoneNumber': toNumber }], 'text': "Your verification code is " + code } response = platform.post('/account/~/extension/~/sms', params) try: ts = time.time() timeStamp = str(math.floor(ts)) query = "UPDATE users SET code= " + code + ", codeexpiry= " + timeStamp + " WHERE email='" + email + "'" cur = conn.cursor() cur.execute(query) conn.commit() conn.close() return createResponse(ResCode.LOCKED, message) except Error as e: conn.close() return databaseError() except Exception as e: conn.close() message = "Cannot send verification code. Please click the Resend button to try again." return createResponse(ResCode.UNKNOWN, message)
def login(): global platform if os.environ.get("ENVIRONMENT_MODE") == "sandbox": rcsdk = SDK(os.environ.get("CLIENT_ID_SB"), os.environ.get("CLIENT_SECRET_SB"), 'https://platform.devtest.ringcentral.com') username = os.environ.get("USERNAME_SB") pwd = os.environ.get("PASSWORD_SB") else: rcsdk = SDK(os.environ.get("CLIENT_ID_PROD"), os.environ.get("CLIENT_SECRET_PROD"), 'https://platform.ringcentral.com') username = os.environ.get("USERNAME_PROD") pwd = os.environ.get("PASSWORD_PROD") platform = rcsdk.platform() try: platform.login(username, '', pwd) res = readCallLogs() return json.dumps(res) except Exception as e: errorRes = {"calllog_error": "Cannot login."} return errorRes
def main(): cache = get_file_cache() # Create SDK instance sdk = SDK(APP_KEY, APP_SECRET, SERVER) platform = sdk.platform() # Set cached authentication data platform.auth().set_data(cache) try: platform.is_authorized() print('Authorized already by cached data') except Exception as e: platform.login(USERNAME, EXTENSION, PASSWORD) print('Authorized by credentials') # Perform refresh by force platform.refresh() print('Refreshed') set_file_cache(platform.auth().data()) print("Authentication data has been cached")
def main(): cache = get_file_cache() # Create SDK instance sdk = SDK(APP_KEY, APP_SECRET, SERVER) platform = sdk.platform() # Set cached authentication data platform.auth().set_data(cache) # Check authentication try: platform.is_authorized() print('Authorized already by cached data') except Exception as e: platform.login(USERNAME, EXTENSION, PASSWORD) print('Authorized by credentials') # Perform refresh by force platform.refresh() print('Refreshed') # Simple GET response = platform.get('/account/~/extension/~') user = response.json() user_id = str(user.id) print('User loaded ' + user.name + ' (' + user_id + ')') print('Headers ' + str(response.response().headers)) # Multipart response try: multipart_response = platform.get('/account/~/extension/' + user_id + ',' + user_id + '/presence').multipart() print 'Multipart 1\n' + str(multipart_response[0].json_dict()) print 'Multipart 2\n' + str(multipart_response[1].json_dict()) except ApiException as e: print 'Cannot load multipart' print 'URL ' + e.api_response().request().url print 'Response' + str(e.api_response().json()) # Pubnub notifications example def on_message(msg): print(msg) def pubnub(): try: s = sdk.create_subscription() s.add_events(['/account/~/extension/~/message-store']) s.on(Events.notification, on_message) s.register() while True: sleep(0.1) except KeyboardInterrupt: print("Pubnub listener stopped...") p = Process(target=pubnub) try: p.start() except KeyboardInterrupt: p.terminate() print("Stopped by User") set_file_cache(platform.auth().data()) print("Authentication data has been cached") print("Wait for notification...")
class OPENRC(): def __init__(self): self.configuration_filename = './conf.json' self.rcsdk = '' self.platform = '' self.db_handle = CINSERTDB() self.recording_filenames = {} self.audio_file_folder = './audio_files/' def initialize(self): if not self.is_file_exist(self.configuration_filename): print("[ERROR] configuration file not present") return False self.config = self.read_json_file(self.configuration_filename) #ringcentral credentials RINGCENTRAL_CLIENTID = self.config['clientId'] RINGCENTRAL_CLIENTSECRET = self.config['clientSecret'] RINGCENTRAL_SERVER = 'https://platform.devtest.ringcentral.com' self.RINGCENTRAL_USERNAME = self.config['username'] self.RINGCENTRAL_PASSWORD = self.config['rc_password'] self.RINGCENTRAL_EXTENSION = self.config['extensionId'] #aws credentials self.AWS_ACCESS_KEY = self.config['AWS_ACCESS_KEY'] self.AWS_SECRET_KEY = self.config['AWS_SECRET_KEY'] #wasabi credentials self.WASABI_ACCESS_KEY = self.config['WASABI_ACCESS_KEY'] self.WASABI_SECRET_KEY = self.config['WASABI_SECRET_KEY'] self.rcsdk = SDK(RINGCENTRAL_CLIENTID, RINGCENTRAL_CLIENTSECRET, RINGCENTRAL_SERVER) self.platform = self.rcsdk.platform() return True def is_file_exist(self, filename): if os.path.exists(filename): return True else: return False def checking_folder_existence(self, dest_dir): if not os.path.exists(dest_dir): os.mkdir(dest_dir) print("Directory ", dest_dir, " Created ") else: pass #print("Directory " , dest_dir , " Exists ") return dest_dir def read_json_file(self, filename): data = {} with open(filename) as json_data: data = json.load(json_data) return data def write_json_file(self, data, filename): with open(filename, 'w') as outfile: json.dump(data, outfile, indent=4) def get_time_stamp(self): return time.strftime('%Y-%m-%d') def login(self): try: print("Signing in ringcentral account....") result = self.platform.login(self.RINGCENTRAL_USERNAME, self.RINGCENTRAL_EXTENSION, self.RINGCENTRAL_PASSWORD) #print(result.json_dict()) #access_token = result.json_dict()['access_token'] return True except: print("[Error]Signing in error....") return False def get_call_logs(self, view='Detailed', with_rec=True): try: params = { 'view': view, 'withRecording': with_rec, 'dateFrom': '2019-10-23' } #print(params) resp = self.platform.get( '/restapi/v1.0/account/~/extension/~/call-log', params) data = resp.json_dict() return data except: return False def logout(self): try: return self.platform.logout() except: return False def refresh_token(self): try: return self.platform.refresh() except: return False def get_call_recording_metadata(self, resp): return resp.raw().info() def download_single_call_recording(self, recording_id): print("Checking recording calls...") self.checking_folder_existence(self.audio_file_folder) if recording_id: resp = self.platform.get( f'/restapi/v1.0/account/~/recording/{recording_id}/content') metadata = self.get_call_recording_metadata(resp) file_name = self.audio_file_folder + metadata.getlist( 'Content-Disposition')[0].split('=')[1] file_size = int(metadata.getheaders("Content-Length")[0]) print("Downloading: %s Bytes: %s" % (file_name, file_size)) audio_file = open(file_name, "wb") audio_file.write(resp.body()) audio_file.close() print("Finished Downloading: %s Bytes: %s" % (file_name, file_size)) print() return file_name def download_all_call_recordings(self): data = self.get_call_logs() main_list = [] #print(json.dumps(data,indent=4)) for record in range(len(data['records'])): sub_dict = {} sub_dict['call_id'] = data['records'][record]['id'] sub_dict['session_id'] = data['records'][record]['sessionId'] recording_id = data['records'][record]['recording']['id'] content_uri = data['records'][record]['recording']['contentUri'] sub_dict['file_name'] = self.download_single_call_recording( recording_id) main_list.append(sub_dict) self.recording_filenames['data'] = main_list def interfaceing_database(self, data): self.db_handle.inserting_in_db(data['records']) def saving_to_csv(self, data): data_dir = self.db_handle.checking_folder_existence('./data/') csv_filename = data_dir + 'csv_file.csv' for record in data['records']: self.db_handle.json_to_csv(record, csv_filename) def do_transcribe(self): aws = CTRANSCRIBE() procesed_filename = 'transcibed.json' if self.is_file_exist(procesed_filename): already_transcribe_data = self.read_json_file(procesed_filename) else: already_transcribe_data = [] for file in range(len(self.recording_filenames['data'])): if self.recording_filenames['data'][file][ 'file_name'] not in already_transcribe_data: if aws.initialize('aws', self.AWS_ACCESS_KEY, self.AWS_SECRET_KEY): pass if not aws.is_bucket_present( self.config['current_bucket_name']): print(self.config['current_bucket_name'], " not present, so creating one.") aws.create_bucket(self.config['current_bucket_name']) contents = aws.listing_bucket_contents( self.config['current_bucket_name']) if self.recording_filenames['data'][file][ 'file_name'] not in contents: print( "Uploading file: ", self.recording_filenames['data'][file] ['file_name'], " on AWS-S3") aws.upload_file( self.recording_filenames['data'][file] ['file_name'], self.config['current_bucket_name'], self.recording_filenames['data'][file] ['file_name'].replace('./audio', 'audio')) else: print(self.recording_filenames['data'][file], " already present on AWS S3 bucket: ", self.config['current_bucket_name']) all_jobs = aws.list_jobs() current_job_name = "job_" job_names_list = [] for job in all_jobs['TranscriptionJobSummaries']: if current_job_name in job['TranscriptionJobName']: try: job_names_list.append( int(job['TranscriptionJobName'].replace( current_job_name, ''))) except: pass if len(job_names_list) > 0: current_job_name += str(max(job_names_list)) else: current_job_name += '0' #for file in range(len(self.recording_filenames['data'])): job_uri = "https://" + self.config[ 'current_bucket_name'] + ".s3.us-east-2.amazonaws.com/" + self.recording_filenames[ 'data'][file]['file_name'].replace( './audio', 'audio') current_job_name = "job_" + str( int(current_job_name.replace('job_', '')) + 1) print("Current Job Name: ", current_job_name) print() response = aws.do_transcribe(current_job_name, job_uri) print("transcibe job finished for: ", current_job_name) print() print( 'Downloading output json file: ', self.recording_filenames['data'][file] ['file_name'].replace('.mp3', '.json')) urllib.request.urlretrieve( response['TranscriptionJob']['Transcript'] ['TranscriptFileUri'], self.recording_filenames['data'] [file]['file_name'].replace('.mp3', '.json')) json_data = self.read_json_file( self.recording_filenames['data'][file] ['file_name'].replace('.mp3', '.json')) print( "Updating the json data in the Database with call_id: ", self.recording_filenames['data'][file]['call_id'], " and session_id: ", self.recording_filenames['data'][file]['session_id']) self.db_handle.updating_json_data( self.recording_filenames['data'][file]['call_id'], self.recording_filenames['data'][file]['session_id'], json_data) print( "Deleting file from AWS server: ", self.recording_filenames['data'][file] ['file_name'].replace('./audio', 'audio')) aws.deleting_file_from_aws( self.config['current_bucket_name'], self.recording_filenames['data'][file] ['file_name'].replace('./audio', 'audio')) print() if aws.initialize('wasabi', self.WASABI_ACCESS_KEY, self.WASABI_SECRET_KEY): if not aws.is_bucket_present( self.config['current_bucket_name']): print(self.config['current_bucket_name'], " not present, so creating one.") aws.create_bucket(self.config['current_bucket_name']) contents = aws.listing_bucket_contents( self.config['current_bucket_name']) if self.recording_filenames['data'][file][ 'file_name'] not in contents: print( "Uploading file: ", self.recording_filenames['data'][file] ['file_name'], " on WASABI SERVER") aws.upload_file( self.recording_filenames['data'][file] ['file_name'], self.config['current_bucket_name'], self.recording_filenames['data'][file] ['file_name'].replace('./audio', 'audio')) else: print(file, " already present on wasabit S3 bucket: ", self.config['current_bucket_name']) if self.is_file_exist(procesed_filename): already_transcribe_data_new = self.read_json_file( procesed_filename) else: already_transcribe_data_new = [] already_transcribe_data_new.append( self.recording_filenames['data'][file]['file_name']) self.write_json_file(already_transcribe_data_new, procesed_filename) else: print("already transcrobed: ", self.recording_filenames['data'][file]['file_name']) self.db_handle.close_api()
class MyWindow(Gtk.Window): def __init__(self): self.db = TinyDB('database.json') self.sdk = SDK(RINGCENTRAL_CLIENT_ID, RINGCENTRAL_CLIENT_SECRET, RINGCENTRAL_SERVER_URL) #self.auth_url = RINGCENTRAL_SERVER_URL + '/restapi/oauth/authorize?response_type=code&client_id=' + RINGCENTRAL_CLIENT_ID + '&state=initialState' #self.response = requests.get(self.auth_url) self.platform = self.sdk.platform() self.platform.login(RINGCENTRAL_LOGIN, RINGCENTRAL_EXT, RINGCENTRAL_PASS) """ self.db.insert( {'id':'1', 'workiz':False, 'phnumber':"+one", 'cust_name':"blahblahblah"} ) self.db.insert( {'id':'2', 'workiz':False, 'phnumber':"+two", 'cust_name':"blahblahblah"} ) self.db.insert( {'id':'3', 'workiz':False, 'phnumber':"+three", 'cust_name':"blahblahblah"} ) self.db.insert( {'id':'4', 'workiz':False, 'phnumber':"+one", 'cust_name':"blahblahblah"} ) self.db.insert( {'id':'5', 'workiz':False, 'phnumber':"+two", 'cust_name':"blahblahblah"} ) self.db.insert( {'id':'6', 'workiz':False, 'phnumber':"+three", 'cust_name':"blahblahblah"} ) self.db.insert( {'id':'7', 'workiz':False, 'phnumber':"+one", 'cust_name':"blahblahblah"} ) self.db.insert( {'id':'8', 'workiz':False, 'phnumber':"+two", 'cust_name':"blahblahblah"} ) self.db.insert( {'id':'9', 'workiz':False, 'phnumber':"+three", 'cust_name':"blahblahblah"} ) """ Gtk.Window.__init__(self, title="Documented Call Log") self.set_default_size(1000, 400) self.set_border_width(3) self.notebook = Gtk.Notebook() self.add(self.notebook) ################### ###### PAGE 1 ##### ################### self.page1 = Gtk.Box() self.page1.set_border_width(10) self.liststore = Gtk.ListStore(bool, str, str, str, str, str, str, str) treeview = Gtk.TreeView(model=self.liststore) renderer_toggle = Gtk.CellRendererToggle() renderer_toggle.connect("toggled", self.on_cell_toggled) column_toggle = Gtk.TreeViewColumn("Workiz", renderer_toggle, active=0) treeview.append_column(column_toggle) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Phone Number", renderer_text, text=1) treeview.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Customer Name", renderer_text, text=2) treeview.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("ID", renderer_text, text=3) treeview.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Date and Time", renderer_text, text=4) column_text.set_sort_column_id(4) treeview.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Action", renderer_text, text=5) treeview.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Result", renderer_text, text=6) treeview.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Length", renderer_text, text=7) treeview.append_column(column_text) self.liststore.set_sort_func(0, self.compare, None) #self.page1.add(treeview) scroll_list1 = Gtk.ScrolledWindow() scroll_list1.set_vexpand(True) scroll_list1.set_hexpand(True) scroll_list1.add(treeview) self.page1.add(scroll_list1) self.button1 = Gtk.Button(label="Refresh") self.button1.connect("clicked", self.on_subscription) self.page1.add(self.button1) self.notebook.append_page(self.page1, Gtk.Label('Inbox') ) ################### ###### PAGE 2 ##### ################### self.page2 = Gtk.Box() self.page2.set_border_width(10) self.liststore2 = Gtk.ListStore(bool, str, str, str, str, str, str, str) treeview2 = Gtk.TreeView(model=self.liststore2) renderer_toggle2 = Gtk.CellRendererToggle() renderer_toggle2.connect("toggled", self.on_cell_toggled_2) column_toggle = Gtk.TreeViewColumn("Workiz", renderer_toggle2, active=0) treeview2.append_column(column_toggle) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Phone Number", renderer_text, text=1) treeview2.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Customer Name", renderer_text, text=2) treeview2.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("ID", renderer_text, text=3) treeview2.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Date and Time", renderer_text, text=4) column_text.set_sort_column_id(4) treeview2.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Action", renderer_text, text=5) treeview2.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Result", renderer_text, text=6) treeview2.append_column(column_text) renderer_text = Gtk.CellRendererText() column_text = Gtk.TreeViewColumn("Length", renderer_text, text=7) treeview2.append_column(column_text) self.liststore2.set_sort_func(0, self.compare, None) #self.page2.add(treeview2) scroll_list = Gtk.ScrolledWindow() scroll_list.set_vexpand(True) scroll_list.set_hexpand(True) scroll_list.add(treeview2) self.page2.add(scroll_list) ###### PAGE 2 ##### self.notebook.append_page( self.page2, Gtk.Image.new_from_icon_name( "help-about", Gtk.IconSize.MENU ) ) self.read_database() #res = self.platform.get('/account/~/call-log') #self.on_subscription() def compare(model, row1, row2, user_data): sort_column, _ = model.get_sort_column_id() value1 = model.get_value(row1, sort_column) value2 = model.get_value(row2, sort_column) if value1 < value2: return -1 elif value1 == value2: return 0 else: return 1 def on_cell_toggled(self, widget, path): Workizq = Query() self.liststore[path][0] = not self.liststore[path][0] self.db.update( {'workiz': self.liststore[path][0] }, Workizq.id == self.liststore[path][3] ) self.read_database() def on_cell_toggled_2(self, widget, path): Workizq = Query() self.liststore2[path][0] = not self.liststore2[path][0] self.db.update( {'workiz': self.liststore2[path][0] }, Workizq.id == self.liststore2[path][3] ) self.read_database() def read_database(self): self.liststore.clear() self.liststore2.clear() workizq = Query() db_list = self.db.search( (workizq.workiz == False) ) for list_item in (db_list): lenstr = str((int(list_item['length'])/60)) lenstr2 = lenstr[:lenstr.find(".")+3] lctime = list_item['date_time'].replace("T", " ").replace("Z", "") lctimeT = strptime(lctime[:lctime.find(".") ], "%Y-%m-%d %H:%M:%S") lctime2 = strftime("%Y-%m-%d %H:%M:%S", localtime(timegm(lctimeT))) self.liststore.append( [list_item['workiz'], list_item['phnumber'], list_item['cust_name'], list_item['id'], lctime2, list_item['action'], list_item['result'], lenstr2] ) db_list = self.db.search( (workizq.workiz == True) ) for list_item in (db_list): lenstr = str((int(list_item['length'])/60)) lenstr2 = lenstr[:lenstr.find(".")+3] lctime = list_item['date_time'].replace("T", " ").replace("Z", "") lctimeT = strptime(lctime[:lctime.find(".") ], "%Y-%m-%d %H:%M:%S") lctime2 = strftime("%Y-%m-%d %H:%M:%S", localtime(timegm(lctimeT))) self.liststore2.append( [list_item['workiz'], list_item['phnumber'], list_item['cust_name'], list_item['id'], lctime2, list_item['action'], list_item['result'], lenstr2] ) self.liststore.set_sort_column_id(4, 1) self.liststore2.set_sort_column_id(4, 1) def on_subscription(self, widget=''): #res = self.platform.get('/account/~/phone-number') #list1 = res.json().records[0].phoneNumber #liststr = str(list1) #print('Phone Number: ' + liststr ) #res = self.platform.get('/account/~/extension/' + RINGCENTRAL_EXT + '/call-log') res = self.platform.get('/account/~/call-log') #res = msg #print(res.json().records) idq_rc = Query() for record in res.json().records: db_list = self.db.search( (idq_rc.id == record.sessionId) ) if not db_list: #if not record.from_.name: if not hasattr(record.from_, "name"): cust_name = 'CUSTOMER' #if 1 == 1: if record.to.phoneNumber == RINGCENTRAL_PHONE: self.db.insert( { 'id':record.sessionId, 'workiz':False, 'phnumber':record.from_.phoneNumber, 'cust_name':cust_name, 'date_time':record.startTime, 'length':str(record.duration), 'action':record.action, 'result':record.result } ) self.read_database()
def main(): sdk = SDK(APP_KEY, APP_SECRET, SERVER) platform = sdk.platform() platform.login(USERNAME, EXTENSION, PASSWORD) TF_NUMBER = '18883303674' def customizesmsbatch(): #POST Body print("Starting to Compose the SMS Body") requestBody = { 'from': TF_NUMBER, 'text': 'Broadcast SMS', 'messages': [{ 'to': ["+14083388064"], 'text': 'This is for Dibyendu, stay safe' }, { "to": ["+14087187847"], 'text': 'This is for Baisakhi, stay safe' }] } print("########SMS Body Composed #############") try: print("#########Just Before Sending SMS###############") response = platform.post('/account/~/a2p-sms/batch', requestBody) print(response.json()) print("############SMS sent. Batch id: " + response.json().id) resp = platform.get('/restapi/v1.0/account/~/a2p-sms/batch/' + response.json().id) print(resp.text()) except ApiException as e: print("Error while Sending SMS" + e) # This is to Send SMS in a Batch def broadcastsmsbatch(): #POST Body print("Starting to Compose the SMS Body") requestBody = { 'from': TF_NUMBER, 'text': 'Broadcast SMS', 'messages': [{ 'to': ["+14083388064"] }, { "to": ["+14083388064"] }] } print("########SMS Body Composed#############") try: print("#########Just Before Sending SMS###############") response = platform.post('/account/~/a2p-sms/batch', requestBody) print("############SMS sent. Batch id: " + response.json().id) resp = platform.get('/restapi/v1.0/account/~/a2p-sms/batch/' + response.json().id) print(resp.text()) except ApiException as e: print("Error while Sending SMS" + e) ####################################################################################################### def getbatchstatus(id): print("Starting to get SMS Batch Status") try: batchId = id print("#########Getting Batch Status###############") response = platform.get('/restapi/v1.0/account/~/a2p-sms/batch/' + batchId) print(response.text()) except ApiException as e: print("Error while Getting batch Status" + e) ################################################################### ####################################################################################################### def getmessagestatus(id): print("Starting to get SMS Message Status") try: batchId = id print("#########Getting SMS Status###############") endpoint = '/restapi/v1.0/account/~/a2p-sms/messages?batchid=' + batchId print(endpoint) response = platform.get( '/restapi/v1.0/account/~/a2p-sms/messages?batchId=' + batchId) print(response.text()) except ApiException as e: print("Error while Getting Message Status" + e) ################################################################### def getmessagestatusById(id): print("Starting to get SMS Message Status") try: messageId = id print("#########Getting SMS Status###############") response = platform.get( '/restapi/v1.0/account/~/a2p-sms/messages/' + messageId) print(response.text()) except ApiException as e: print("Error while Getting Message Status" + e) ################################################################### #broadcastsmsbatch() #customizesmsbatch() #getbatchstatus("0ab4f3d1-9ee6-4d3f-accd-4b0567eb2992") #getmessagestatus("0ab4f3d1-9ee6-4d3f-accd-4b0567eb2992") getmessagestatusById('40146')
def login_to_platform(): sdk = SDK(client_id, client_secret, server_url) platform = sdk.platform() platform.login(username, extension, password) return platform
from ringcentral import SDK sdk = SDK("client_id", "client_secret", "server_url") platform = sdk.platform() platform.login("username", "extension", "password") def get_account_call_queues(): try: resp = platform.get('/restapi/v1.0/account/~/call-queues') for record in resp.json().records: if record.name == "Demo call queue": read_call_queue_info(record.id) except ApiException as e: print(e) def read_call_queue_info(id): try: resp = platform.get('/restapi/v1.0/account/~/call-queues/' + id) print(resp.text()) except ApiException as e: print(e) get_account_call_queues()
class RingCentralEngageVoice(object): def __init__( self, clientId = '', clientSecret = '', server = SERVER, rcServer = RINGCENTRAL_SERVER, apiPrefix = 'voice' ): self.clientId = clientId self.clientSecret = clientSecret self.server = server self.apiPrefix = apiPrefix self._token = None self._timer = None self.auto_refresh = False if clientId != '': self.rc = SDK(clientId, clientSecret, rcServer) self.isLegacy = self.isLegacyServer(server) self.debug = False @property def token(self): return self._token @token.setter def token(self, value): self._token = value def refresh(self): # pragma: no cover self.getToken( self.token['refreshToken'] ) def isLegacyServer (self, server): return server in LEGACY_SERVERS def joinPath(self, path): if path.startswith('http'): return path v = urlparse.urlparse(self.server) p = v.path arr = [p, self.apiPrefix, path] if self.isLegacy: arr = [p, path] return urlparse.urljoin( self.server, "/".join( urlparse.quote_plus(part.strip("/"), safe="/") for part in arr ) ) def patchHeader(self, header = {}): user_agent_header = '{name} Python {major_lang_version}.{minor_lang_version} {platform}'.format( name = 'ringcentral/engage-voice', major_lang_version = sys.version_info[0], minor_lang_version = sys.version_info[1], platform = platform.platform(), ) shareHeaders = { 'Content-Type': 'application/json', 'User-Agent': user_agent_header, 'RC-User-Agent': user_agent_header, 'X-User-Agent': user_agent_header, } authHeader = {} if self.isLegacy: authHeader = self._legacyHeader() else: # pragma: no cover authHeader = { 'Authorization': self._autorization_header() } return _.assign(shareHeaders, authHeader, header or {}) def _request( self, method, endpoint, params = None, json = None, data = None, files = None, multipart_mixed = False, headers = None ): url = self.joinPath(endpoint) newHeaders = self.patchHeader(headers) req = Request(method, url, params = params, data = data, json = json, files = files, headers = newHeaders) prepared = req.prepare() if multipart_mixed: prepared.headers['Content-Type'] = prepared.headers['Content-Type'].replace('multipart/form-data;', 'multipart/mixed;') if self.debug: # pragma: no cover pretty_print_POST(prepared) s = Session() r = s.send(prepared) try: r.raise_for_status() except: if 'expired' in r.text: # pragma: no cover self.refresh() newHeaders = self.patchHeader(headers) req = Request(method, url, params = params, data = data, json = json, files = files, headers = newHeaders) prepared = req.prepare() s = Session() r = s.send(prepared) try: r.raise_for_status() except: raise Exception('HTTP status code: {0}\n\n{1}'.format(r.status_code, r.text)) else: raise Exception('HTTP status code: {0}\n\n{1}'.format(r.status_code, r.text)) return r def authorize (self, **kwargs): if self.isLegacy: self.legacyAuthorize(**kwargs) else: # pragma: no cover plat = self.rc.platform() plat.login(**kwargs) self.getToken() def legacyAuthorize (self, **kwargs): self.getLegacyToken(**kwargs) def getLegacyToken (self, username = '', password = ''): url = f'{self.server}/api/v1/auth/login' body = f'username={quote(username)}&password={password}' res = self._request( 'post', url, data = body, headers = { 'Content-Type': 'application/x-www-form-urlencoded' } ) r = res.json() self.token = r # def revokeLegacyToken (self): # if self._token is not None: # token = self.token['authToken'] # self.delete(f'/api/v1/admin/token/{token}') def getToken (self, refreshToken = None): # pragma: no cover url = '' token = '' body = '' if refreshToken is None: url = f'{self.server}/api/auth/login/rc/accesstoken?includeRefresh=true' token = self.rc.platform().auth().data()['access_token'] body = f'rcAccessToken={token}&rcTokenType=Bearer' else: url = f'{self.server}/api/auth/token/refresh' token = refreshToken body = f'refresh_token={token}&rcTokenType=Bearer' res = self._request( 'post', url, data = body, headers = { 'Content-Type': 'application/x-www-form-urlencoded' } ) self.token = res.json() def _legacyHeader (self): accessToken = '' if self.token: accessToken = self.token['authToken'] return { 'X-Auth-Token': accessToken } def get(self, endpoint, params = None): return self._request('GET', endpoint, params) def post(self, endpoint, json = None, params = None, data = None, files = None, multipart_mixed = False): return self._request('POST', endpoint, params, json, data, files, multipart_mixed) def put(self, endpoint, json = None, params = None, data = None, files = None, multipart_mixed = False): return self._request('PUT', endpoint, params, json, data, files, multipart_mixed) def patch(self, endpoint, json = None, params = None, data = None, files = None, multipart_mixed = False): return self._request('PATCH', endpoint, params, json, data, files, multipart_mixed) def delete(self, endpoint, params = None): return self._request('DELETE', endpoint, params) def _autorization_header(self): if self.token: return 'Bearer {access_token}'.format(access_token = self.token['accessToken']) return 'Basic basic'
class RCClientBot: def __init__(self): self.rcsdk = SDK(os.environ['BOT_CLIENT_ID'],os.environ['BOT_CLIENT_SECRET'],os.environ['RINGCENTRAL_ENV']) self.platform = self.rcsdk.platform() def get_bot_info(self,event): body = parse_qs(event['body']) print(event) header = { 'Authorization': 'bearer ' + body['access_token'][0] } bot_extension_info = self.platform.get('/account/~/extension/~', headers=header, skip_auth_check=True) bot_extension_info = bot_extension_info.json_dict() bot_info = { 'id':str(bot_extension_info['id']), 'extension':str(bot_extension_info['extensionNumber']), 'access_token': body['access_token'][0], 'client_id': body['client_id'][0], 'creator_extension_id': body['creator_extension_id'][0], 'creator_account_id': body['creator_account_id'][0], } return bot_info def get_bot_info_prod(self,creator_app_data): data = self.platform.auth().data() header = { 'Authorization': 'bearer ' + data['access_token'] } bot_extension_info = self.platform.get('/account/~/extension/~', headers=header, skip_auth_check=True) bot_extension_info = bot_extension_info.json_dict() bot_info = { 'id':str(bot_extension_info['id']), 'extension':str(bot_extension_info['extensionNumber']), 'access_token': data['access_token'], 'client_id': creator_app_data['client_id'], 'creator_extension_id': creator_app_data['creator_extension_id'], 'creator_account_id': creator_app_data['creator_account_id'], } return bot_info def save_token(self, bot_info): table = dynamodb.Table(os.environ['BOT_DYNAMODB_TABLE']) table.put_item(Item=bot_info) print('successfully added token to table!!') def delete_token(self,bot_id): table = dynamodb.Table(os.environ['BOT_DYNAMODB_TABLE']) table.delete_item( Key={ 'id': bot_id } ) def auth_with_code(self, code): redirect_url = os.environ['REDIRECT_HOST']+'/bot/oauth_prod' print('redirect_url: '+redirect_url) self.platform.login(code=code,redirect_uri=redirect_url) print('data from platform:') print(self.platform.auth().data()) def add_token_to_platform(self,bot_id): try: table = dynamodb.Table(os.environ['BOT_DYNAMODB_TABLE']) result = table.get_item( Key={ 'id': bot_id } ) data = self.platform.auth().data() print(result) print(result['Item']) data['access_token'] = result['Item']['access_token'] data['token_type'] = 'bearer' data['expires_in'] = 500000000 self.platform.auth().set_data(data) print('successfully got token from table') return True except Exception as error: print('failed to get token from table!!') logging.error(error) return False def subscribe(self,bot_id): print('subscribing..') if self.add_token_to_platform(bot_id): requestData = { "eventFilters": [ #Get Glip Post Events "/restapi/v1.0/glip/posts", #Get Glip Group Events "/restapi/v1.0/glip/groups", #Get Bot Create/Remove events "/restapi/v1.0/account/~/extension/~" ], "deliveryMode": { "transportType": "WebHook", "address": os.environ['REDIRECT_HOST'] + "/bot/receive" }, "expiresIn": 500000000 } data = self.platform.auth().data() header = { 'Authorization': 'bearer ' + data['access_token'] } self.platform.post('/subscription',body=requestData, headers=header, skip_auth_check=True) response = { "statusCode": 200, "body": "" } return response else: response = { "statusCode": 500, "body": "could not add token to db" } return response def post_message(self,bot_id,group_id,message): if self.add_token_to_platform(bot_id): messageData = { "text":message } data = self.platform.auth().data() header = { 'Authorization': 'bearer ' + data['access_token'] } print('posted message '+message) self.platform.post('/restapi/v1.0/glip/groups/'+group_id+'/posts',body=messageData, headers=header, skip_auth_check=True) else: print("failed to add token to platform") def post_message_card(self,bot_id,group_id,message): if self.add_token_to_platform(bot_id): data = self.platform.auth().data() header = { 'Authorization': 'bearer ' + data['access_token'] } print('posted message ') print(message) self.platform.post('/restapi/v1.0/glip/groups/'+group_id+'/posts',body=message, headers=header, skip_auth_check=True)
# https://developers.ringcentral.com/my-account.html#/applications # Find your credentials at the above url, set them as environment variables, or enter them below # PATH PARAMETERS accountId = '<ENTER VALUE>' # OPTIONAL QUERY PARAMETERS queryParams = { #'type': 'User', #'searchString': '<ENTER VALUE>', #'department': '<ENTER VALUE>', #'siteId': '<ENTER VALUE>', #'featureEnabled': true, #'orderBy': 'name', #'perPage': 000, #'page': 1 } import os from ringcentral import SDK rcsdk = SDK(os.environ['clientId'], os.environ['clientSecret'], os.environ['serverURL']) platform = rcsdk.platform() platform.login(os.environ['username'], os.environ['extension'], os.environ['password']) r = platform.get(f'/restapi/v1.0/account/{accountId}/emergency-address-auto-update/users', queryParams) # PROCESS RESPONSE
class RCClientHelper: def __init__(self): self.rcsdk = SDK(os.environ['HELPER_CLIENT_ID'], os.environ['HELPER_CLIENT_SECRET'], os.environ['RINGCENTRAL_ENV']) self.platform = self.rcsdk.platform() #Return true if the access_token has been successfully added to dynamodb-table def save_token(self): #save account_id, access token, refresh_token and expire_time to table #account_id is the key try: data = self.platform.auth().data() print(data) # data['expire_time'] = Decimal(data['expire_time']) # data['refresh_token_expire_time'] = Decimal(data['refresh_token_expire_time']) # data['expires_in'] = Decimal(data['expires_in']) # data['refresh_token_expires_in'] = Decimal(data['refresh_token_expires_in']) table = dynamodb.Table(os.environ['HELPER_DYNAMODB_TABLE']) response = table.update_item( Key={'owner_id': data['owner_id']}, UpdateExpression= 'set access_token = :at, expire_time = :ex_t, expires_in = :ex_in, refresh_token = :rt, refresh_token_expire_time = :rt_ex_t, refresh_token_expire_in = :rt_ex_in, remember = :r, ex_scope = :s, token_type = :tt ', ExpressionAttributeValues={ ':at': data['access_token'], ':ex_t': Decimal(data['expire_time']), ':ex_in': Decimal(data['expires_in']), ':rt': data['refresh_token'], ':rt_ex_t': Decimal(data['refresh_token_expire_time']), ':rt_ex_in': Decimal(data['refresh_token_expires_in']), ':r': data['remember'], ':s': data['scope'], ':tt': data['token_type'] }, ReturnValues="ALL_NEW") print('Print response:\n') print(response) #table.put_item(Item=data) print('successfully added token to table!!') ret_val = { 'bot_id': response['Attributes']['bot_id'], 'group_id': response['Attributes']['group_id'], 'owner_id': response['Attributes']['owner_id'], } return ret_val except Exception as error: print('failed to add token to table!!') logging.error(error) traceback.print_exc() raise error def delete_token(self, bot_id): table = dynamodb.Table(os.environ['HELPER_DYNAMODB_TABLE']) response = table.query(IndexName=os.environ['HELPER_DYNAMODB_TABLE'], KeyConditionExpression=Key('bot_id').eq(bot_id)) for item in response['Items']: table.delete_item(Key={'owner_id': item['owner_id']}) def save_bot_and_group_id(self, owner_id, bot_id, group_id): data = {'owner_id': owner_id, 'bot_id': bot_id, 'group_id': group_id} table = dynamodb.Table(os.environ['HELPER_DYNAMODB_TABLE']) table.put_item(Item=data) print('Account Id, Bot Id and Group Id have been added to the table.') #return true on success and false on failure def add_token_to_platform(self, item): #add the retrived values to the platform self.platform.auth().set_data(item) def auth_with_code(self, code): #authorize with code try: redirect_url = os.environ['REDIRECT_HOST'] + '/helper/oauth' print('redirect_url: ' + redirect_url) self.platform.login(code=code, redirect_uri=redirect_url) except Exception as error: logging.error(error) raise error def get_auth_url(self): #get the url the user can use to authorize the helper app redirect_url = os.environ['REDIRECT_HOST'] + '/helper/oauth' host = os.environ['RINGCENTRAL_ENV'] query = urlencode({ 'response_type': 'code', 'redirect_uri': redirect_url, 'client_id': os.environ['HELPER_CLIENT_ID'], 'state': '', 'brand_id': '', 'display': '', 'prompt': '', 'localeId': '', 'ui_locales': '', 'ui_options': '' }) return f'{host}/restapi/oauth/authorize?{query}' def get_token_from_db(self, owner_id): #return the table item for the given account id table = dynamodb.Table(os.environ['HELPER_DYNAMODB_TABLE']) try: result = table.get_item(Key={'owner_id': owner_id}) return result['Item'] except Exception as error: logging.error(error) return None def has_valid_token(self, owner_id): item = self.get_token_from_db(owner_id) if item == None: return False else: self.add_token_to_platform(item) if self.platform.auth().access_token_valid(): print('Has valid access token!') print(self.platform.auth().data()) return True elif self.platform.auth().refresh_token_valid(): print('Has valid refresh token') self.platform.refresh() self.save_token() return True else: print('Has invalid access and refresh token') return False def get(self, url, query_params): print('getting info from ringcentral platform') ret_val = self.platform.get(url, query_params=query_params) print(ret_val.json_dict()) return ret_val.json_dict() def put(self, url, body): print('updating ringcentral settings') self.platform.put(url, body=body)