def startGame(args,user_integration):
object = UserIntegration.objects.get(yellowant_integration_id=user_integration.yellowant_integration_id)
board = chess.Board()
object.board_state = INITIAL_BOARD + INITIAL_BOARD_REST
object.save()
print("inside start game")
print(user_integration.id)
m = MessageClass()
color = args['Color']
# if color == "White":
# MOVE_FLAG = 0
# else:
# MOVE_FLAG = 1
#
# #board = chess.Board()
m.message_text = "You chose " + color
attachment = MessageAttachmentsClass()
print(color + " to move")
if (color=="Black"):
m = playComputer(args,user_integration)
return m
print(IMAGE_URL + INITIAL_BOARD)
attachment.image_url = IMAGE_URL + INITIAL_BOARD
field1 = AttachmentFieldsClass()
field1.title = "Move"
field1.value = color + " to move"
attachment.attach_field(field1)
button = MessageButtonsClass()
button.text = "Make move"
button.value = "Make move"
button.name = "Make move"
button.command = {
"service_application": str(user_integration.yellowant_integration_id),
"function_name": "makemove",
"inputs": ["move"],
"data": {"move": "testing"},
}
attachment.attach_button(button)
button1 = MessageButtonsClass()
button1.text = "Play Computer"
button1.value = "Play Computer"
button1.name = "Play Computer"
button1.command = {"service_application": str(user_integration.yellowant_integration_id), "function_name": "playcomputer",
"data": {"move": "testing"},
}
attachment.attach_button(button1)
m.attach(attachment)
#m.image_url = "http://www.fen-to-image.com/image/rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
return m
def modify_state(args, user_integration):
access_token_object = Servicenow_model.objects.get(
user_integration=user_integration.id)
access_token = access_token_object.access_token
headers = {
'Accept': 'application/json',
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + access_token
}
sys_id = args.get('sys_id')
new_state = int(args.get('state'))
body = {
"incident_state": new_state,
"state": new_state,
}
instance = access_token_object.instance
url = " https://" + instance + ".service-now.com/api/now/table/incident/" + sys_id
response = requests.put(url=url, headers=headers, data=json.dumps(body))
message = MessageClass()
message.message_text = "Incident state changed"
return message
def get_organization(self, args):
"""
This function gets the ID and the name of the organization. This is a picklist function
used by all other functions
"""
headers = {
"Content-Type":
"application/json",
"Authorization":
"Zoho-oauthtoken" + " " + self.zohoinvoice_access_token
}
url = settings.ZOHO_ORGANIZATION_URL
response = requests.get(url, headers=headers)
# print(response.text)
# print(type(response))
response_json = response.json()
# print(response_json)
data = response_json['organizations']
message = MessageClass()
message.message_text = "Organization list:"
name_list = {'org': []}
for i in data:
name_list['org'].append({
"id": str(i['organization_id']),
"name": str(i['name'])
})
message.data = name_list
print(message.data)
return message.to_json()
def responsewebhook(request, hash_str=""):
"""Whenever a new response is completed the user gets notified"""
try:
ya_obj = YellowUserToken.objects.get(webhook_id=hash_str)
except YellowUserToken.DoesNotExist:
return HttpResponse("Not Authorized", status=403)
try:
data_obj = json.loads(request.body)
print(data_obj)
notification_type = data_obj['event_type']
if notification_type == "response_completed":
message = MessageClass()
message.message_text = "New survey response completed"
message.data = data_obj
yauser_integration_object = YellowAnt(
access_token=ya_obj.yellowant_token)
send_message = yauser_integration_object.create_webhook_message(\
requester_application=ya_obj.yellowant_intergration_id, \
webhook_name="response_completed", **message.get_dict())
return HttpResponse("webhook_receiver/webhook_receiver/")
except Exception as e:
print(str(e))
return HttpResponse("Empty body")
def close_incident(args, user_integration):
access_token_object = Servicenow_model.objects.get(
user_integration=user_integration.id)
access_token = access_token_object.access_token
headers = {
'Accept': 'application/json',
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + access_token
}
sys_id = args.get('sys_id')
close_code = args.get('close_code')
close_notes = args.get('close_notes')
body = {
"close_code": close_code,
"close_notes": close_notes,
"state": "7",
"caller_id": sys_id,
}
instance = access_token_object.instance
url = " https://" + instance + ".service-now.com/api/now/table/incident/" + sys_id
response = requests.put(url=url, headers=headers, data=json.dumps(body))
message = MessageClass()
message.message_text = "Incident Closed"
return message
def attach_disk(args, user_integration):
message = MessageClass()
GROUP_NAME = args.get("Resource-Group")
VM_NAME = args.get("vm_name")
DISK_NAME = args.get("disk_name")
credentials, subscription_id = get_credentials(user_integration)
compute_client = ComputeManagementClient(credentials, subscription_id)
virtual_machine = compute_client.virtual_machines.get(GROUP_NAME, VM_NAME)
print('Starting attachment')
# Attach data disk
data_disk = compute_client.disks.get(GROUP_NAME, DISK_NAME)
print('\nGet Virtual Machine by Name')
virtual_machine = compute_client.virtual_machines.get(GROUP_NAME, VM_NAME)
# Attach data disk
print('\nAttach Data Disk')
virtual_machine.storage_profile.data_disks.append({
'lun':
12,
'name':
data_disk.name,
'create_option':
DiskCreateOption.attach,
'managed_disk': {
'id': data_disk.id
}
})
async_disk_attach = compute_client.virtual_machines.create_or_update(
GROUP_NAME, virtual_machine.name, virtual_machine)
#async_disk_attach.wait()
message.message_text = "Disk attached to VM"
return message
def forward_message(self, args):
"""Forwards a message"""
print("In forward_message")
msg_id = args["Message-Id"]
to_recepients = self.args["toRecipients"]
message = args["Message"]
to_recepients = to_recepients.split(',')
get_forward_url = graph_endpoint.format(
'/me/messages/{}/forward'.format(msg_id))
for i in range(0, len(to_recepients)):
data = {
"comment": message,
"toRecipients": [{
"emailAddress": {
"address": to_recepients[i]
}
}]
}
r = make_api_call('POST',
get_forward_url,
self.access_token,
payload=data)
if r.status_code == 202:
if i == (len(to_recepients) - 1):
message = MessageClass()
message.message_text = "Forwarded Successfully"
return message.to_json()
else:
print("In continue")
continue
else:
return "{0}: {1}".format(r.status_code, r.text)
def change_user_subcription(self, args):
if 'id' not in args or 'subscription' not in args:
return self.generate_simple_message(
"Please provide parameter 'id' and 'subscription' in your command"
)
else:
#Check if Id is a number
if args['id'].is_digit():
user_id = int(args['id'])
else:
return self.generate_simple_message(
"Please provide an integer value for parameter 'id' in your command"
)
try:
#Searching for user with id
user_object = SiteUsers.objects.get(id=user_id)
#changing subscription value
user_object.subscription = args['subscription']
except SiteUsers.DoesNotExist:
#return error message if user does not exist
return self.generate_simple_message(
"User with that id does not exist")
user_details_message = MessageClass()
user_details_message.message_text = "User subscription changed"
user_json = serializers.serialize("json", user_object)
#Adding JSON data to message for use in workflows
user_details_message.data = user_json
return user_details_message.to_json()
def Collectors_Available(self, args):
print("In view_details")
survey_id = args["SurveyId"]
url = "https://api.surveymonkey.com/v3/surveys/%s/collectors"%(survey_id)
message = MessageClass()
result = "Collectors available are: \n"
try:
response = requests.get(url, headers=self.headers)
response_json = response.json()
data = response_json["data"]
send_data = {\
"collectors":[]\
}
for i in range(len(data)):
obj = data[i]
name = obj["name"]
id = obj["id"]
send_data["collectors"].append({"id":id, "name":name})
result = result + str(i+1)+": "+ name+" "+ "ID is: "+ id+"\n"
message.data = send_data
message.message_text = result
print(send_data)
# use inbuilt sdk method to_json to return message in a json format accepted by YA
return message.to_json()
except Exception as e:
print(str(e))
traceback.print_exc()
def list_user_details(self, args):
if 'id' not in args:
return self.generate_simple_message(
"Please provide parameter 'id' in your command")
else:
#Check if Id is a number
if args['id'].is_digit():
user_id = int(args['id'])
else:
return self.generate_simple_message(
"Please provide an integer value for parameter 'id' in your command"
)
try:
#Searching for user with id
user_object = SiteUsers.objects.get(id=user_id)
except SiteUsers.DoesNotExist:
#return error message if user does not exist
return self.generate_simple_message(
"User with that id does not exist")
user_details_message = MessageClass()
user_details_message.message_text = "User Id - %d, Fullname - %s, Date joined - %s, Subscription - %s" % (
user_id, user_object.full_name, user_object.date_joined,
user_object.subscription)
user_json = serializers.serialize("json", user_object)
#Adding JSON data to message for use in workflows
user_details_message.data = user_json
return user_details_message.to_json()
def Survey_Lang_Available(self, args):
# Return the available languages in which the Survey can be translated.
print("In SurveyLangAvailable")
survey_id = args["Survey-ID"]
url = "https://api.surveymonkey.com/v3/surveys/%s/languages"%(survey_id)
response = requests.get(url, headers=self.headers)
response_json = response.json()
print(response_json)
data = response_json["data"]
message = MessageClass()
result = "Languages available are: \n"
for i in range(len(data)):
obj = data[i]
lang = obj["name"]
id = obj["id"]
result = result + lang + " " + "ID is: "+ id+ "\n"
message.message_text = result
# use inbuilt sdk method to_json to return message in a json format accepted by YA
return message.to_json()
# def Collectors(self, args):
# print("In collectors")
# CollectorId = args["CollectorId"]
#
# url = "https://api.surveymonkey.com/v3/collectors/%s"%(CollectorId)
# response = requests.get(url, headers=self.headers)
# response_json = response.json()
#
# print(response_json)
# return "Hey"
def all_page_ids(self,args):
'''
Get all page ids for the user
Basic inactive function to get dynamic inputs in all other functions.
'''
sot = self.statuspage_access_token_object
print(sot.user_integration_id)
page_objects = PageDetail.objects.filter(user_integration_id=sot)
m = MessageClass()
data = []
m.message_text = "Here are your pages" #:\n" if len(page_objects) > 0 else "You don't have any pages."
for page_object in page_objects:
url = (settings.SP_API_BASE1 + page_object.page_id + ".json")
response = requests.get(url, headers=self.headers)
response_json = response.json()
m.message_text += "{} - {}\n".format(response_json["name"], page_object.page_id)
data.append({"name": response_json["name"],"page_id":str(page_object.page_id)})
# m = MessageClass()
# data = []
# data.append({"page_id":"dfdsdfvd"})
# m.message_text = "Lol"
m.data = data
print(m.data)
return m.to_json()
def search_by_email(args, user_integration):
agc = Agile_Credentials.objects.get(
user_integration_id=user_integration.id)
APIKEY = agc.AGILE_API_KEY
EMAIL = agc.AGILE_EMAIL_ID
DOMAIN = agc.AGILE_DOMAIN_NAME
BASE_URL = "https://" + DOMAIN + ".agilecrm.com/dev/api/"
email = args['EmailID']
url = BASE_URL + "contacts/search/email/" + email
headers = {
'Accept': 'application/json',
'content-type': contenttype,
}
response = requests.get(url, headers=headers, auth=(EMAIL, APIKEY))
m = MessageClass()
m.message_text = str(response.text)
#print (str(response.text) + "test")
a = json.loads(response.text)
print("\n\nFULL NAME:" + a['properties'][0]['value'] + " " +
a['properties'][1]['value'] + "\nEMAIL:" +
a['properties'][4]['value'] + "\nPHONE:" +
a['properties'][5]['value'])
m.message_text = "\n\nFULL NAME:" + a['properties'][0]['value'] + " " + a[
'properties'][1]['value'] + "\nEMAIL:" + a['properties'][4][
'value'] + "\nPHONE:" + a['properties'][5]['value']
return m
def mail_folder(self, args):
"""gives the relationship between the mail and the folder to which it belongs"""
print("In mail_folder")
get_mailFolder_url = graph_endpoint.format('/me/mailFolders')
r = make_api_call('GET', get_mailFolder_url, self.access_token)
send_data = {'values': []}
message = MessageClass()
if r.status_code == 200:
obj = r.json()
data = obj["value"]
for i in range(0, len(data)):
obj1 = data[i]
send_data['values'].append({
'displayName':
obj1["displayName"],
'id':
obj1["id"],
'parentFolderId':
str(obj1["parentFolderId"])[0:75]
})
message.data = send_data
print("returning")
return message.to_json()
else:
print(r.status_code)
print(r.text)
return "{0}: {1}".format(r.status_code, r.text)
def show_impact(args, user_integration):
m = MessageClass()
data = {'list': []}
data['list'].append({"Value": 1, "name": "High"})
data['list'].append({"Value": 2, "name": "Medium"})
data['list'].append({"Value": 3, "name": "Low"})
m.data = data
return m
def create_vm(args, user_integration):
threadObj = CreateVMThread(args, user_integration)
# async_vm_start = compute_client.virtual_machines.start(GROUP_NAME, VM_NAME)
# async_vm_start.wait()
threadObj.daemon = True
threadObj.start()
message = MessageClass()
message.message_text = "Creating VM"
return message
def states(args, user_integration):
m = MessageClass()
data = {'list': []}
data['list'].append({"State": 1, "State-name": "New"})
data['list'].append({"State": 2, "State-name": "In Progress"})
data['list'].append({"State": 3, "State-name": "On Hold"})
m.data = data
return m
def list_all(args, user_integration):
#print("LIST")
bxc = BOX_Credentials.objects.get(user_integration_id=user_integration)
ACCESS_TOKEN = bxc.BOX_ACCESS_TOKEN
#print(ACCESS_TOKEN)
REFRESH_TOKEN = bxc.BOX_REFRESH_TOKEN
#print(REFRESH_TOKEN+" refreshtoken")
# Log the token we're using & starting call
logging.info('Using Refresh Token: %s' % REFRESH_TOKEN)
# Get new access & refresh tokens
#print("logged")
getTokens = requests.post(oauth2URL,
data={
'grant_type': 'refresh_token',
'refresh_token': REFRESH_TOKEN,
'client_id': clientId,
'client_secret': clientSecret
})
#print("GOT TOKENS")
# If the above gives a 4XX or 5XX error
#getTokens.raise_for_status()
# Get the JSON from the above
newTokens = getTokens.json()
#print("GOT NEW TOKEN")
# Get the new access token, valid for 60 minutes
accessToken = newTokens['access_token']
refreshToken = newTokens['refresh_token']
# print("New accessToken " + accessToken)
# print("New refreshToken " + refreshToken)
bxc.BOX_REFRESH_TOKEN = refreshToken
bxc.BOX_ACCESS_TOKEN = accessToken
bxc.save()
# Get the new access token, valid for 60 minutes
CLIENT_ID = settings.CLIENT_ID
CLIENT_SECRET = settings.CLIENT_SECRET
oauth2 = OAuth2(CLIENT_ID, CLIENT_SECRET, access_token=accessToken)
#print("listing...")
client = Client(oauth2, LoggingNetwork())
items = client.folder(folder_id='0').get_items(limit=1000, offset=0)
#print("List of all files and folders\n")
attachment = MessageAttachmentsClass()
m = MessageClass()
x = ''
for item in items:
field = AttachmentFieldsClass()
field.title = item['name']
field.value = item['id']
#print("Name: "+item['name']+" ID: "+item['id'])
x = x + "Name: " + item['name'] + " ID: " + item['id'] + "\n"
attachment.attach_field(field)
m.attach(attachment)
return m
def run(self):
"""Method which runs when the thread is started"""
global GROUP_NAME, VM_NAME, USERNAME, PASSWORD
message = MessageClass()
credentials, subscription_id = get_credentials(self.user_integration)
compute_client = ComputeManagementClient(credentials, subscription_id)
network_client = NetworkManagementClient(credentials, subscription_id)
GROUP_NAME = self.args.get("Resource-Group")
VM_NAME = self.args.get("VM-Name")
NIC_NAME = self.args.get("nic_name")
IP_CONFIG_NAME = self.args.get("ipconfig_name")
USERNAME = self.args.get("username")
PASSWORD = self.args.get("password")
VNET_NAME = self.args.get("vnet_name")
SUBNET_NAME = self.args.get("subnet_name")
LOCATION = self.args.get("location")
try:
# Create a NIC
nic = create_nic(network_client, VNET_NAME, SUBNET_NAME,
IP_CONFIG_NAME, NIC_NAME)
#############
# VM Sample #
#############
# Create Linux VM
print('\nCreating Linux Virtual Machine')
vm_parameters = create_vm_parameters(nic.id, VM_REFERENCE['linux'],
VM_NAME, USERNAME, PASSWORD,
LOCATION)
async_vm_creation = compute_client.virtual_machines.create_or_update(
GROUP_NAME, VM_NAME, vm_parameters)
# async_vm_creation.wait()
message.message_text = "You are Virtual Machine is being created"
except CloudError:
print('A VM operation failed:', traceback.format_exc(), sep='\n')
message.message_text = "There was an error.Please try again"
else:
webhook_message = MessageClass()
webhook_message.message_text = "VM created successfully"
attachment = MessageAttachmentsClass()
attachment.title = VM_NAME
webhook_message.attach(attachment)
yellowant_user_integration_object = YellowAnt(
access_token=self.user_integration.yellowant_integration_token)
yellowant_user_integration_object.create_webhook_message(
requester_application=self.user_integration.
yellowant_integration_id,
webhook_name="start_vm_webhook",
**webhook_message.get_dict())
print('All example operations completed successfully!')
def chooseColor(args,user_integration):
"""
Picklist function to return colors.
"""
m = MessageClass()
data = {'list': []}
data['list'].append({"Color": "White"})
data['list'].append({"Color": "Black"})
m.data = data
return m
def reauthenticate(args, user_integration):
xcr = Xero_Credentials.objects.get(user_integration_id=user_integration.id)
print("user integration-" + str(xcr.user_integration_id))
credentials = PublicCredentials('BGJJ6JSSEAGIRWQ9SYKA1T3O7Y6IPF',
'2JRHWN0QQ1K0AHVDZVUPKCVIQKUUNB',
'http://127.0.0.1:8000/return/')
print(credentials.url)
webbrowser.open(credentials.url)
time.sleep(30)
# time.sleep(60) for the user
credentials.verify(views.token)
xero = Xero(credentials)
saved_state = credentials.state
print(str(saved_state) + "saved_state")
s1 = saved_state['oauth_expires_at']
s2 = saved_state['oauth_authorization_expires_at']
print("\n\n")
print(s1)
print(s2)
s1 = s1.strftime('%Y%m%d%H%M%S%f')
s2 = s2.strftime('%Y%m%d%H%M%S%f')
# new_date=datetime.datetime.strptime(s1,'%Y%m%d%H%M%S%f')
# print(new_date)
t1 = saved_state['oauth_token']
t2 = saved_state['oauth_token_secret']
obj = Xero_Credentials.objects.get(user_integration_id=user_integration.id)
obj.XERO_OAUTH_TOKEN = t1
obj.XERO_OAUTH_SECRET = t2
obj.XERO_EXPIRE = s1
obj.XERO_AUTH_EXPIRE = s2
obj.XERO_UPDATE_LOGIN_FLAG = True
print(str(obj.XERO_AUTH_EXPIRE) + " helloooo")
obj.save()
# global flag
# global saved_state
# credentials = PublicCredentials(consumer_key, consumer_secret)
m = MessageClass()
m.message_text = "Your account has been authenticated"
# if flag == 0:
# code=args['7-Digit-Code']
# print(code)
# print(credentials.url)
# credentials.verify(input("enter"))
# saved_state = credentials.state
# new_credentials=PublicCredentials(**saved_state)
# xero=Xero_Credentials(new_credentials)
# flag = 1
# print("Your account has been authenticated")
# attachment=MessageAttachmentsClass()
# field=AttachmentFieldsClass()
# field.title="Your account is now authenticated"
# attachment.attach_field(field)
# m.attach(attachment)
return m
def list_regions(args, user_integration):
m = MessageClass()
credentials, subscription_id = get_credentials(user_integration)
client = ResourceManagementClient(credentials, subscription_id)
data = {'list': []}
for item in client.resource_groups.list():
print(item.name)
data['list'].append({"Resource_name": item.name})
print(data)
m.data = data
return m
def show_priorities(args, user_integration):
m = MessageClass()
data = {'list': []}
data['list'].append({"Value": 1, "name": "Critical"})
data['list'].append({"Value": 2, "name": "High"})
data['list'].append({"Value": 3, "name": "Moderate"})
data['list'].append({"Value": 4, "name": "Low"})
data['list'].append({"Value": 5, "name": "Planning"})
m.data = data
return m
def delete_resource_group(args, user_integration):
message = MessageClass()
credentials, subscription_id = get_credentials(user_integration)
resource_client = ResourceManagementClient(credentials, subscription_id)
GROUP_NAME = args.get("Resource-Group")
print('\nDelete Resource Group')
delete_async_operation = resource_client.resource_groups.delete(GROUP_NAME)
#delete_async_operation.wait()
print("Resource group has been deleted")
message.message_text = "Your resource group has been deleted"
return message
def get_incident(self, args):
"""
Get information corresponding to the given incident_uuid
"""
incident_id = args['Incident-UUID']
url = (settings.VICTOROPS_INCIDENT_ALERT_URL + incident_id)
# get request to victorops server
response = requests.get(url, headers=self.headers)
# print(response)
response_json = response.json()
# print(response_json)
message = MessageClass()
message.message_text = "Incident Details"
# if the ID does not have an incident associated with it.
if response.status_code == 422:
attachment = MessageAttachmentsClass()
attachment.text = "No incident found for the given ID!"
message.attach(attachment)
return message.to_json()
else:
attachment = MessageAttachmentsClass()
field1 = AttachmentFieldsClass()
field1.title = "Incident Description"
field1.value = response_json['entityDisplayName']
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "Incident Body"
field2.value = response_json['stateMessage']
attachment.attach_field(field2)
field3 = AttachmentFieldsClass()
field3.title = "Entity ID"
field3.value = response_json['entityId']
attachment.attach_field(field3)
field4 = AttachmentFieldsClass()
field4.title = "Incident Type"
field4.value = response_json['messageType']
attachment.attach_field(field4)
try:
# val = response_json['ackAuthor']
field5 = AttachmentFieldsClass()
field5.title = "Acknowledged By"
field5.value = response_json['ackAuthor']
attachment.attach_field(field5)
except:
pass
message.attach(attachment)
# print(message)
# message = json.dumps(message)
# return message
# print(type(message))
return message.to_json()
def user_details(args, user_integration):
bxc = BOX_Credentials.objects.get(user_integration_id=user_integration)
ACCESS_TOKEN = bxc.BOX_ACCESS_TOKEN
REFRESH_TOKEN = bxc.BOX_REFRESH_TOKEN
bxc = BOX_Credentials.objects.get(user_integration_id=user_integration)
ACCESS_TOKEN = bxc.BOX_ACCESS_TOKEN
#print(ACCESS_TOKEN)
REFRESH_TOKEN = bxc.BOX_REFRESH_TOKEN
#print(REFRESH_TOKEN + " refreshtoken")
# Log the token we're using & starting call
logging.info('Using Refresh Token: %s' % REFRESH_TOKEN)
# Get new access & refresh tokens
getTokens = requests.post(oauth2URL,
data={
'grant_type': 'refresh_token',
'refresh_token': REFRESH_TOKEN,
'client_id': clientId,
'client_secret': clientSecret
})
# If the above gives a 4XX or 5XX error
# getTokens.raise_for_status()
# Get the JSON from the above
newTokens = getTokens.json()
# Get the new access token, valid for 60 minutes
accessToken = newTokens['access_token']
refreshToken = newTokens['refresh_token']
#print("New accessToken " + accessToken)
#print("New refreshToken " + refreshToken)
bxc.BOX_REFRESH_TOKEN = refreshToken
bxc.BOX_ACCESS_TOKEN = accessToken
bxc.save()
CLIENT_ID = settings.CLIENT_ID
CLIENT_SECRET = settings.CLIENT_SECRET
oauth2 = OAuth2(CLIENT_ID, CLIENT_SECRET, access_token=accessToken)
attachment = MessageAttachmentsClass()
client = Client(oauth2, LoggingNetwork())
items = client.folder(folder_id='0').get_items(limit=1000, offset=0)
# print("List of all files and folders\n")
m = MessageClass()
#print("The users are:\n")
my = client.user(user_id='me').get()
field = AttachmentFieldsClass()
field.title = "LOGIN ID"
field.value = my['login']
attachment.attach_field(field)
m.attach(attachment)
#print(my)
return m
def stop_vm(args, user_integration):
GROUP_NAME = args.get('group_name')
VM_NAME = args.get('vm_name')
message = MessageClass()
credentials, subscription_id = get_credentials(user_integration)
compute_client = ComputeManagementClient(credentials, subscription_id)
print('\nStop VM')
async_vm_stop = compute_client.virtual_machines.power_off(
GROUP_NAME, VM_NAME)
message.message_text = VM_NAME + " stopped"
return message
def next_page(self, args):
"""This returns the list of functions in the next page"""
message = MessageClass()
region = args['Region']
next_marker = args['NextMarker']
aws_lambda = boto3.client(service_name='lambda', region_name=region,
api_version=None, use_ssl=True, verify=None,
endpoint_url=None, aws_access_key_id=self.aws_access_key,
aws_secret_access_key=self.aws_secret_token,
aws_session_token=None, config=None)
# Gets the next ten functions in lambda
response = aws_lambda.list_functions(Marker=next_marker, MaxItems=10)
functions = [Function['FunctionName'] for Function in response['Functions']]
for Function in functions:
attachment = MessageAttachmentsClass()
attachment.title = Function
# Button to get the logs of the function
button = MessageButtonsClass()
button.text = "Get Logs"
button.value = "Get Logs"
button.name = "Get Logs"
button.command = {"service_application": self.yellowant_integration_id,
"function_name": "get-logs",
"data": {"FunctionName": Function, "Region": region}}
attachment.attach_button(button)
# Button to invoke the function
button1 = MessageButtonsClass()
button1.text = "Invoke"
button1.value = "Invoke"
button1.name = "Invoke"
button1.command = {"service_application": self.yellowant_integration_id,
"function_name": "invoke-async",
"data": {"Function-Name": Function, "Region": region},
"inputs": ["input"]}
attachment.attach_button(button1)
message.attach(attachment)
try:
# Button to get the functions in next page, Checks actually if next page exists or not
attachment = MessageAttachmentsClass()
button2 = MessageButtonsClass()
button2.text = "Next Page"
button2.value = "Next Page"
button2.name = "Next Page"
button2.command = {"service_application": self.yellowant_integration_id,
"function_name": "next-page",
"data": {"NextMarker": response['NextMarker'], "Region": region}}
attachment.attach_button(button2)
message.attach(attachment)
message.message_text = "The Functions present are:"
except:
message.message_text = "This is the Last page and The Functions present are: "
return message.to_json()
def get_space_usage(self, args):
print("In get_space_usage")
headers = {
'Authorization': 'Bearer ' + str(self.dropbox_access_token),
}
# Consuming the API
r = requests.post('https://api.dropboxapi.com/2/users/get_space_usage',
headers=headers)
# Response check
if r.status_code == requests.codes.ok:
# Fetching response in JSON
response = r.content.decode("utf-8")
response = json.loads(response)
print(response)
#Creating a message object from YA SDK
message = MessageClass()
message.message_text = "Space usage/allocation details :"
attachment = MessageAttachmentsClass()
used_gb = float(response['used'] / 1000000000)
allocated_gb = float(response['allocation']['allocated'] /
1000000000)
field1 = AttachmentFieldsClass()
field1.title = "Used : "
field1.value = str(
Decimal(str(used_gb)).quantize(Decimal('.01'),
rounding=ROUND_DOWN)) + " gb"
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "Allocated : "
field2.value = str(
Decimal(str(allocated_gb)).quantize(
Decimal('.01'), rounding=ROUND_DOWN)) + " gb"
attachment.attach_field(field2)
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def get_domain(self, args):
""" Get a single domain """
# API parameteres for getting account information
auth = ("api", self.mailgun_access_token)
# Consuming the API
r = requests.get("https://api.mailgun.net/v3/domains/" +
str(self.domain_name),
auth=auth)
print(self.mailgun_access_token)
# Response check
if r.status_code == requests.codes.ok:
# Getting response in JSON
print(json.loads(r.content.decode("utf-8")))
response = json.loads(r.content.decode("utf-8"))
# Creating message objects to structure the message to be shown
message = MessageClass()
message.message_text = "Domain details :"
attachment = MessageAttachmentsClass()
field1 = AttachmentFieldsClass()
field1.title = "Domain :"
field1.value = response['domain']["name"]
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "State :"
field2.value = response['domain']["state"]
attachment.attach_field(field2)
field3 = AttachmentFieldsClass()
field3.title = "Created at :"
field3.value = response['domain']['created_at']
attachment.attach_field(field3)
field4 = AttachmentFieldsClass()
field4.title = "Type :"
field4.value = response['domain']['type']
attachment.attach_field(field4)
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def get_account_info(self,args):
print("In get_company_info")
endpoint = "https://api.dropboxapi.com/2/users/get_account"
# API parameteres for getting account information
headers = {
'Authorization': 'Bearer ' + self.dropbox_access_token,
'Content-Type': 'application/json',
}
data = {"account_id": str(self.account_id)}
# Consuming the API
r = requests.post('https://api.dropboxapi.com/2/users/get_account', headers=headers, json=data)
# Response check
if r.status_code == requests.codes.ok:
# Getting response in JSON
response = r.content.decode("utf-8")
response = json.loads(response)
# Creating message objects to structure the message to be shown
message = MessageClass()
message.message_text = "User Account Details :"
attachment = MessageAttachmentsClass()
field1 = AttachmentFieldsClass()
field1.title = "Name :"
field1.value = response["name"]["display_name"]
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "E-mail :"
field2.value = response["email"]
attachment.attach_field(field2)
attachment.image_url = response["profile_photo_url"]
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def get_space_usage(self,args):
print("In get_space_usage")
headers = {
'Authorization': 'Bearer ' + str(self.dropbox_access_token),
}
# Consuming the API
r = requests.post('https://api.dropboxapi.com/2/users/get_space_usage', headers=headers)
# Response check
if r.status_code == requests.codes.ok:
# Fetching response in JSON
response = r.content.decode("utf-8")
response = json.loads(response)
print(response)
#Creating a message object from YA SDK
message = MessageClass()
message.message_text = "Space usage/allocation details :"
attachment = MessageAttachmentsClass()
used_gb = float(response['used']/1000000000)
allocated_gb = float(response['allocation']['allocated']/1000000000)
field1 = AttachmentFieldsClass()
field1.title = "Used : "
field1.value = str(Decimal(str(used_gb)).quantize(Decimal('.01'), rounding=ROUND_DOWN)) + " gb"
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "Allocated : "
field2.value = str(Decimal(str(allocated_gb)).quantize(Decimal('.01'), rounding=ROUND_DOWN)) + " gb"
attachment.attach_field(field2)
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def get_all_shared_folders(self,args):
print("In get_all_shared_folders")
endpoint = "https://api.dropboxapi.com/2/sharing/list_folders"
headers = {
'Authorization': 'Bearer ' + str(self.dropbox_access_token),
'Content-Type': 'application/json',
}
data = {"limit": 100,"actions": []}
# Consuming the API
r = requests.post(endpoint, headers=headers, json=data)
# Response check
if (r.status_code == requests.codes.ok):
response = r.content.decode("utf-8")
response = json.loads(response)
print(response)
#Creating message from YA SDK
message = MessageClass()
message.message_text = "All shared file details :"
attachment = MessageAttachmentsClass()
for i in range(0,len(response['entries'])):
field1 = AttachmentFieldsClass()
field1.title = "Name :"
field1.value = response['entries'][i]['name']
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "Preview URL :"
field2.value = response['entries'][i]['preview_url']
attachment.attach_field(field2)
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def download_file(self,args):
print("In download_file")
# Fetching the arguments passed from slack
path = args['path']
# API call parameters for creating a customer
headers = {
'Authorization': 'Bearer ' + self.dropbox_access_token,
'Content-Type': 'application/json',
}
data = {"path": path}
# Consuming the API
r = requests.post('https://api.dropboxapi.com/2/files/get_temporary_link', headers=headers, json=data)
# Response check
if (r.status_code == requests.codes.ok):
# Getting the response
response = r.content.decode("utf-8")
response = json.loads(response)
print(response)
# Creating message using YA SDK
message = MessageClass()
message.message_text = "Temporary link to download :"
attachment = MessageAttachmentsClass()
field1 = AttachmentFieldsClass()
field1.title = "This link expires in 4 Hr :"
field1.value = response['link']
attachment.attach_field(field1)
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def get_shared_links(self,args):
print("In get_shared_links")
flag = False
# Arguments passed from slack
# For the optional argument
try:
path = args['path']
flag = True
except:
flag = False
headers = {
'Authorization': 'Bearer ' + self.dropbox_access_token,
'Content-Type': 'application/json',
}
endpoint = 'https://api.dropboxapi.com/2/sharing/list_shared_links'
if flag == True:
data = {"path": path}
else:
data = {}
# Consuming the API
r = requests.post(endpoint, headers=headers, json=data)
# Response check
if r.status_code == requests.codes.ok:
# Getting response in JSON
response = r.content.decode("utf-8")
response = json.loads(response)
print(response)
links = response['links']
message = MessageClass()
message.message_text = "List of all shared links :"
attachment = MessageAttachmentsClass()
for i in range(0,len(links)):
try:
field1 = AttachmentFieldsClass()
field1.title = "Name :"
field1.value = links[i]['name']
attachment.attach_field(field1)
except KeyError : 'name'
# field2 = AttachmentFieldsClass()
# field2.title = "Type :"
# field2.value = links[i]['.tag']
# attachment.attach_field(field2)
field3 = AttachmentFieldsClass()
field3.title = "Preview URL :"
field3.value = links[i]['url']
attachment.attach_field(field3)
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def webhook(request, hash_str=""):
'''Respond to the webhook verification (GET request) by echoing back the challenge parameter.'''
print("Inside webhook")
if request.method == "GET":
print("Inside webhook validation")
challenge = request.GET.get('challenge',None)
if challenge != None:
return HttpResponse(challenge,status=200)
else:
return HttpResponse(status=400)
else:
print("In notifications")
webhook_id = hash_str
data = (request.body.decode('utf-8'))
response_json = json.loads(data)
print(response_json)
data = {
"users": [],
"accounts": []
}
try:
yellow_obj = YellowUserToken.objects.get(webhook_id=webhook_id)
print(yellow_obj)
access_token = yellow_obj.yellowant_token
print(access_token)
integration_id = yellow_obj.yellowant_integration_id
service_application = str(integration_id)
print(service_application)
# Creating message object for webhook message
webhook_message = MessageClass()
webhook_message.message_text = "File/Folder updated !"
attachment = MessageAttachmentsClass()
attachment.title = "Updated file/folder details :"
for i in range(0,len(response_json['list_folder']['accounts'])):
field1 = AttachmentFieldsClass()
field1.title = "Id : "
field1.value = response_json['list_folder']['accounts'][i]
data["accounts"].append(response_json['list_folder']['accounts'][i])
attachment.attach_field(field1)
attachment2 = MessageAttachmentsClass()
attachment2.title = "User update details :"
for i in range(0, len(response_json['delta']['users'])):
field2 = AttachmentFieldsClass()
field2.title = "Id : "
field2.value = response_json['delta']['users'][i]
data["users"].append(response_json['delta']['users'][i])
attachment2.attach_field(field2)
button = MessageButtonsClass()
button.name = "1"
button.value = "1"
button.text = "Get all files and folders "
button.command = {
"service_application": service_application,
"function_name": 'get_all_folders',
"data" : {"path": "",
"recursive": True,
"include_media_info": False,
"include_deleted": False,
"include_has_explicit_shared_members": False,
"include_mounted_folders": True}
}
attachment.attach_button(button)
webhook_message.attach(attachment)
webhook_message.attach(attachment2)
#print(integration_id)
print("-----------")
print(data)
print("------------")
webhook_message.data = data
# Creating yellowant object
yellowant_user_integration_object = YellowAnt(access_token=access_token)
# Sending webhook message to user
send_message = yellowant_user_integration_object.create_webhook_message(
requester_application=integration_id,
webhook_name="files_folders_update", **webhook_message.get_dict())
return HttpResponse("OK", status=200)
except YellowUserToken.DoesNotExist:
return HttpResponse("Not Authorized", status=403)
def get_more_folders(self,args):
print("In get_more_folders")
# Fetching arguments passed from Slack
cursor = args['cursor']
# API call parameters for getting customer details
headers = {
'Authorization': 'Bearer ' + self.dropbox_access_token,
'Content-Type': 'application/json',
}
data = {"cursor": cursor}
re = requests.post('https://api.dropboxapi.com/2/files/list_folder/continue', headers=headers,
json=data)
if re.status_code == requests.codes.ok:
res = re.content.decode("utf-8")
res = json.loads(res)
print("----")
print(res)
message = MessageClass()
message.message_text = "More files and folders :"
attachment = MessageAttachmentsClass()
for i in range(0, len(res['entries'])):
field1 = AttachmentFieldsClass()
field1.title = "Name :"
field1.value = res['entries'][i]['name']
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "Type :"
field2.value = res['entries'][i]['.tag']
attachment.attach_field(field2)
attachment2 = MessageAttachmentsClass()
if res['has_more'] == True:
button = MessageButtonsClass()
button.name = "1"
button.value = "1"
button.text = "Get more files and folders"
button.command = {
"service_application": str(self.user_integration.yellowant_integration_id),
"function_name": 'get_more_folders',
"data": {"cursor": res['cursor']}
}
attachment2.attach_button(button)
message.attach(attachment)
message.attach(attachment2)
return message.to_json()
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(re.content.decode("utf-8"))
d = re.content.decode("utf-8")
m.message_text = "{0}: {1}".format(re.status_code, re.text)
return m.to_json()
def search(self,args):
print("In search")
print(args)
path = args['path']
query = args['search']
headers = {
'Authorization': 'Bearer ' + self.dropbox_access_token,
'Content-Type': 'application/json',
}
if path == '/':
path = ""
data = {"path": path,"query": query,"start": 0,"max_results": 100,"mode": "filename"}
# Consuming the API
r = requests.post('https://api.dropboxapi.com/2/files/search', headers=headers, json=data)
# Response check
if r.status_code == requests.codes.ok:
print("---------------")
# Getting response in JSON
r = r.content.decode("utf-8")
response = json.loads(r)
print(response)
# Creating message using YA SDK
message = MessageClass()
if len(response['matches']) == 0:
message.message_text = "No matches !\nPlease search again."
return message.to_json()
message.message_text = "Matches :"
attachment = MessageAttachmentsClass()
for i in range(0, len(response['matches'])):
field1 = AttachmentFieldsClass()
field1.title = "Path:"
field1.value = response['matches'][i]['metadata']['path_display']
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "Name :"
field2.value = response['matches'][i]['metadata']['name']
attachment.attach_field(field2)
field3 = AttachmentFieldsClass()
field3.title = "Type :"
field3.value = response['matches'][i]['metadata']['.tag']
attachment.attach_field(field3)
message.attach(attachment)
return message.to_json()
else:
print("Error")
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def share_folder(self, args):
print("In share_folder")
# Arguments from slack
path = args["path"]
member_policy = args['member_policy']
shared_link_policy = args['shared_link_policy']
if member_policy != 'anyone' and member_policy != "team":
m = MessageClass()
m.message_text = "Invalid value in member_policy argument"
return m.to_json()
if shared_link_policy != 'anyone' and shared_link_policy != "team":
m = MessageClass()
m.message_text = "Invalid value in shared_link_policy argument"
return m.to_json()
# API call parameters for getting all customer ids
headers = {
'Authorization': 'Bearer ' + self.dropbox_access_token,
'Content-Type': 'application/json',
}
data = {"path": path,"acl_update_policy": "editors","force_async": False,"member_policy": member_policy ,"shared_link_policy": shared_link_policy}
# Consuming the API
r = requests.post('https://api.dropboxapi.com/2/sharing/share_folder', headers=headers, json=data)
# Response check
if r.status_code == requests.codes.ok:
# Fetching response in JSON
r = r.content.decode("utf-8")
response = json.loads(r)
print(response)
# Creating a message object using YA SDK functions
m = MessageClass()
m.message_text = "Details for the shared folder : "
attachment = MessageAttachmentsClass()
field1 = AttachmentFieldsClass()
field1.title = "Shared link : "
field1.value = response['preview_url']
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "Visibility :"
field2.value = response['policy']['shared_link_policy']['.tag']
attachment.attach_field(field2)
field3 = AttachmentFieldsClass()
field3.title = "Name :"
field3.value = response['name']
attachment.attach_field(field3)
m.attach(attachment)
return m.to_json()
else:
print("Error")
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def create_folder(self, args):
print("In create_folder")
print(args)
path = args['path']
autorename = args['autorename']
if autorename != 'true' and autorename != 'false':
m = MessageClass()
m.message_text = "Invalid value in autorename argument"
return m.to_json()
headers = {
'Authorization': 'Bearer ' + self.dropbox_access_token,
'Content-Type': 'application/json',
}
if autorename == 'true':
autorename = True
else:
autorename = False
data = {"path": path,"autorename": autorename}
# Consuming the API
r = requests.post('https://api.dropboxapi.com/2/files/create_folder_v2', headers=headers, json=data)
# Response check
if r.status_code == requests.codes.ok:
print("---------------")
# Getting response in JSON
r = r.content.decode("utf-8")
response = json.loads(r)
print(response)
#Creating message using YA SDK
message = MessageClass()
attachment = MessageAttachmentsClass()
attachment2 = MessageAttachmentsClass()
message.message_text = "New folder successfully created"
button = MessageButtonsClass()
button.name = "1"
button.value = "1"
button.text = "Get folder details"
button.command = {
"service_application": str(self.user_integration.yellowant_integration_id),
"function_name": 'get_all_folders',
"data" :{"path": response['metadata']['path_display'],
"recursive": True,
"include_media_info": False,
"include_deleted": False,
"include_has_explicit_shared_members": False,
"include_mounted_folders": True}
}
attachment2.attach_button(button)
message.attach(attachment)
message.attach(attachment2)
return message.to_json()
else:
print("Error")
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def get_all_file_requests(self,args):
print("In get_all_file_requests")
# API call parameters for creating an invoice
headers = {
'Authorization': 'Bearer ' + str(self.dropbox_access_token),
}
# Consuming the API
r = requests.post('https://api.dropboxapi.com/2/file_requests/list', headers=headers)
# Response check
if r.status_code == requests.codes.ok:
response = r.content.decode("utf-8")
response = json.loads(response)
print(response)
# Creating message from YA SDK
message = MessageClass()
attachment = MessageAttachmentsClass()
if len(response) == 0:
message.message_text = "No File Requests"
message.attach(attachment)
return message.to_json()
else:
message.message_text = "All file requests :"
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
def get_all_folders(self,args):
print("In get_all_folders")
# API call parameters for getting all customers
path = args['path']
headers = {
'Authorization': 'Bearer ' + self.dropbox_access_token,
'Content-Type': 'application/json',
}
if path == '/':
path = ""
data = {"path": path,
"recursive": True,
"include_media_info": False,
"include_deleted": False,
"include_has_explicit_shared_members": False,
"include_mounted_folders": True}
# Consuming the API
r = requests.post('https://api.dropboxapi.com/2/files/list_folder', headers=headers, json=data)
# Error check
if r.status_code == requests.codes.ok:
# Getting response in JSON format
response = r.content.decode("utf-8")
response = json.loads(response)
print(response)
message = MessageClass()
message.message_text = "List files and folders :"
attachment = MessageAttachmentsClass()
for i in range(0, len(response['entries'])):
field1 = AttachmentFieldsClass()
field1.title = "Name :"
field1.value = response['entries'][i]['name']
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "Type :"
field2.value = response['entries'][i]['.tag']
attachment.attach_field(field2)
attachment2 = MessageAttachmentsClass()
if response['has_more'] == True:
button = MessageButtonsClass()
button.name = "1"
button.value = "1"
button.text = "Get more files and folders"
button.command = {
"service_application": str(self.user_integration.yellowant_integration_id),
"function_name": 'get_more_folders',
"data": {"cursor": response['cursor']}
}
attachment2.attach_button(button)
message.attach(attachment)
message.attach(attachment2)
return message.to_json()
message.attach(attachment)
return message.to_json()
else:
m = MessageClass()
print(r.content.decode("utf-8"))
d = r.content.decode("utf-8")
m.message_text = "{0}: {1}".format(r.status_code, r.text)
return m.to_json()
