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)
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 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 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)
# 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 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 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 __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
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 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 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 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 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 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 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()
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()
#!/usr/bin/env python
from ringcentral import SDK
import os, sys
CLIENTID = os.environ.get('RC_CLIENT_ID')
CLIENTSECRET = os.environ.get('RC_CLIENT_SECRET')
SERVER = os.environ.get('RC_SERVER_URL')
USERNAME = os.environ.get('RC_USERNAME')
PASSWORD = os.environ.get('RC_PASSWORD')
EXTENSION = os.environ.get('RC_EXTENSION')
rcsdk = SDK(CLIENTID, CLIENTSECRET, SERVER)
platform = rcsdk.platform()
try:
platform.login(USERNAME, EXTENSION, PASSWORD)
except:
sys.exit("Unable to authenticate to platform. Check credentials.")
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:
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'
# 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>'
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'])
builder = rcsdk.create_multipart_builder()
builder.set_body({'type': 'Company'})
binary = ('mygreeting.wav', open('mygreeting.wav', 'r').read(), 'audio/wav')
builder.add(binary)
request = builder.request(f'/restapi/v1.0/account/{accountId}/greeting')
resp = platform.send_request(request)
from ringcentral import SDK
DELIVERY_ADDRESS = '<https://XXXXXXXX.ngrok.io/webhookcallback>'
rcsdk = SDK(os.environ.get('RC_CLIENT_ID'), os.environ.get('RC_CLIENT_SECRET'),
os.environ.get('RC_SERVER_URL'))
platform = rcsdk.platform()
try:
platform.login(os.environ.get('RC_USERNAME'),
os.environ.get('RC_EXTENSION'),
os.environ.get('RC_PASSWORD'))
except:
sys.exit("Unable to authenticate to platform. Check credentials.")
try:
eventFilters = [
'/restapi/v1.0/account/~/extension/~/message-store/instant?type=SMS'
]
params = {
"eventFilters": eventFilters,
"deliveryMode": {
"transportType": 'WebHook',
"address": DELIVERY_ADDRESS
}
}
res = platform.post("/subscription", params)
except Exception as e:
print(f"An exception was thrown: {e}")
else:
print(f'{res}')
def set_file_cache(cache):
if not os.path.isdir(cache_dir):
os.mkdir(cache_dir)
os.system('chmod 777 -R _cache')
f = open(file_path, 'w')
json.dump(cache, f, indent=4)
f.close()
cache = get_file_cache()
__counter__ = AtomicCounter(0)
__check_Count = 0
# Create SDK instance
sdk = SDK(APP_KEY, APP_SECRET, SERVER)
platform = sdk.platform()
# Set cached authentication data
platform.auth().set_data(cache)
def login():
try:
platform.is_authorized()
log.info('Authorized already by cached data')
except Exception as e:
authorize_response = platform.login(USERNAME, EXTENSION, PASSWORD)
if (authorize_response.response().status_code):
if all(k in authorize_response.response().json()
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()
from ringcentral import SDK
RINGCENTRAL_CLIENTID = '<ENTER CLIENT ID>'
RINGCENTRAL_CLIENTSECRET = '<ENTER CLIENT SECRET>'
RINGCENTRAL_SERVER = 'https://platform.devtest.ringcentral.com'
RINGCENTRAL_USERNAME = '******'
RINGCENTRAL_PASSWORD = '******'
RINGCENTRAL_EXTENSION = '<YOUR EXTENSION, PROBABLY "101">'
CHAT_ID = '<GROUP ID>'
rcsdk = SDK( RINGCENTRAL_CLIENTID, RINGCENTRAL_CLIENTSECRET, RINGCENTRAL_SERVER)
platform = rcsdk.platform()
platform.login(RINGCENTRAL_USERNAME, RINGCENTRAL_EXTENSION, RINGCENTRAL_PASSWORD)
endpoint = "/restapi/v1.0/glip/chats/" + CHAT_ID + '/adaptive-cards'
card = {
"type": "AdaptiveCard",
"body": [
{
"type": "TextBlock",
"size": "Medium",
"weight": "Bolder",
"text": "Adaptive Card example"
},
{
"type": "Image",
"url": "https://bit.ly/3nwZbRM"
}
],
server + ';DATABASE=' + database + ';UID=' + username +
';PWD=' + password)
cursor = cnxn.cursor()
# OPTIONAL QUERY PARAMETERS
queryParams = {
'direction': ['Inbound', 'Outbound'],
'type': ['Voice'],
'view': 'Simple',
'dateFrom': dateFrom.strftime("%Y-%m-%dT%H:%M:00.000Z"),
'dateTo': dateTo.strftime("%Y-%m-%dT%H:%M:00.000Z"),
'perPage': 1000
}
#Get call log for the last 15 minutes from Ring Central
rcsdk = SDK(RC_CLIENTID, RC_CLIENTSECRET, RC_SERVER)
platform = rcsdk.platform()
platform.login(RC_USERNAME, RC_EXTENSION, RC_PASSWORD)
responselog = platform.get(f'/restapi/v1.0/account/~/call-log', queryParams)
logging.info('Retrieving call log from RingCentral')
# Add the initial log record to SQL table
logParams = [
dateFrom.strftime("%Y-%m-%dT%H:%M:00.000Z"),
dateTo.strftime("%Y-%m-%dT%H:%M:00.000Z"), 'Process Starting',
responselog.text()
]
qryLogStart = "EXEC [dbo].[usp_Process_RingCentral_CallLog_Master] ?,?,?,?"
cursor.execute(qryLogStart, logParams)
cnxn.commit()
dotenv_path = join(dirname(__file__), '.env')
load_dotenv(dotenv_path)
import base64
import json
import requests
import urllib
from bottle import request, route, run, template
from ringcentral import SDK
myState = 'myState'
token_json = '{}'
rcsdk = SDK(os.environ.get('RC_APP_KEY'), os.environ.get('RC_APP_SECRET'),
os.environ.get('RC_APP_SERVER_URL'))
def authorize_uri(options):
base_url = os.environ.get('RC_APP_SERVER_URL') + '/restapi/oauth/authorize'
params = (('response_type', 'code'),
('redirect_uri', os.environ.get('RC_APP_REDIRECT_URL')),
('client_id', os.environ.get('RC_APP_KEY')), ('state',
options['state']))
qs = urllib.urlencode(params)
auth_url = base_url + '?' + qs
return auth_url
def get_access_token(auth_code):
token_url = os.environ.get('RC_APP_SERVER_URL') + '/restapi/oauth/token'
def main():
cache = get_file_cache()
# Create SDK instance
sdk = SDK(APP_KEY, APP_SECRET, SERVER)
platform = sdk.get_platform()
# Set cached authentication data
# platform.set_auth_data(cache)
# Check authentication
try:
platform.is_authorized()
print('Authorized already by cached data')
except Exception as e:
platform.authorize(USERNAME, EXTENSION, PASSWORD)
print('Authorized by credentials')
# Perform refresh by force
platform.refresh()
print('Refreshed')
# Simple GET
response = platform.get('/account/~/extension/~')
user = response.get_json(True)
user_id = str(user.id)
print('User loaded ' + user.name + ' (' + user_id + ')')
print('Headers ' + str(response.get_headers()))
# Multipart response
try:
multipart_response = platform.get('/account/~/extension/' + user_id + ',' + user_id + '/presence').get_responses()
print 'Multipart 1\n' + str(multipart_response[0].get_json())
print 'Multipart 2\n' + str(multipart_response[1].get_json())
except HttpException as e:
print 'Cannot load multipart'
print 'URL ' + e.get_request().get_url()
print 'Response' + str(e.get_response().get_json())
# Pubnub notifications example
def on_message(msg):
print(msg)
def pubnub():
try:
s = sdk.get_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.get_auth_data())
print("Authentication data has been cached")
print("Wait for notification...")
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...")
# 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
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')
