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():
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...")
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)
