def webhook_delivered(request, webhook_id):
print("In webhook_delivered")
"""
Webhook function to notify user about update in component
"""
urllib.parse.unquote(request.body.decode("utf-8"))
params_dict = urllib.parse.parse_qsl(request.body)
params = dict(params_dict)
#Extracting necessary data
recipient = params[b'recipient'].decode('utf-8')
# Fetching yellowant object
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 = "Mail delivered to " + str(recipient)
attachment = MessageAttachmentsClass()
attachment.title = "Mail Stats upto last 1 month"
button_get_components = MessageButtonsClass()
button_get_components.name = "1"
button_get_components.value = "1"
button_get_components.text = "Get all stats"
button_get_components.command = {
"service_application": service_application,
"function_name": 'get_stats',
"data": {}
}
attachment.attach_button(button_get_components)
webhook_message.data = {"recipient_email_id": recipient}
webhook_message.attach(attachment)
#print(integration_id)
# 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="notify_delivered",
**webhook_message.get_dict())
return HttpResponse("OK", status=200)
except YellowUserToken.DoesNotExist:
return HttpResponse("Not Authorized", status=403)
def update_incident(request,webhook_id):
print("In update_incident")
"""
Webhook function to notify user about update in incident
"""
# Extracting necessary data
data = (request.body.decode('utf-8'))
response_json = json.loads(data)
page_id = response_json['page']['id']
unsubscribe = response_json['meta']['unsubscribe']
incident_id = response_json['incident']['id']
name = response_json['incident']['name']
try:
# Fetching yellowant object
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 = "Updates in incident with Id : " + str(incident_id) + "\nName : " + str(name)
attachment = MessageAttachmentsClass()
attachment.title = "Incident operations"
button_get_incidents = MessageButtonsClass()
button_get_incidents.name = "1"
button_get_incidents.value = "1"
button_get_incidents.text = "Get all incidents"
button_get_incidents.command = {
"service_application": service_application,
"function_name": 'all_incidents',
"data": {
'page_id': page_id
}
}
attachment.attach_button(button_get_incidents)
webhook_message.data = {"page_id": page_id}
webhook_message.attach(attachment)
#print(integration_id)
# 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="incident_updates_webhook", **webhook_message.get_dict())
return HttpResponse("OK", status=200)
except YellowUserToken.DoesNotExist:
return HttpResponse("Not Authorized", status=403)
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 add_new_pipeline(request, webhook_id):
"""
Webhook function to notify user about newly added pipeline
"""
data = request.body
data_string = data.decode('utf-8')
data_json = json.loads(data_string)
name = data_json["current"]['name']
add_time = data_json["current"]['add_time']
url_tile = data_json["current"]['url_title']
order = data_json["current"]['order_nr']
# Fetching yellowant object
yellow_obj = YellowUserToken.objects.get(webhook_id=webhook_id)
access_token = yellow_obj.yellowant_token
integration_id = yellow_obj.yellowant_integration_id
service_application = str(integration_id)
# Creating message object for webhook message
webhook_message = MessageClass()
webhook_message.message_text = "New pipeline created." + "\n" + "The pipeline name : " + str(
name)
attachment = MessageAttachmentsClass()
button_get_pipeline = MessageButtonsClass()
button_get_pipeline.name = "1"
button_get_pipeline.value = "1"
button_get_pipeline.text = "Get all pipelines"
button_get_pipeline.command = {
"service_application": service_application,
"function_name": 'list_pipelines',
"data": {
'data': "test",
}
}
attachment.attach_button(button_get_pipeline)
webhook_message.attach(attachment)
# print(integration_id)
webhook_message.data = {
"Add Time": add_time,
"Url title": url_tile,
"Name": name,
"Order": order,
}
# 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="new_pipeline",
**webhook_message.get_dict())
return HttpResponse("OK", status=200)
def accept(args,user_integration):
"""
Function to accept the invitation from another player.
"""
opponent_user_integration = args.get("user_int")
state = str(uuid.uuid4())
opponent_object = UserIntegration.objects.get(yellowant_integration_id=opponent_user_integration)
opponent_object.playing_state = state
player_object = UserIntegration.objects.get(yellowant_integration_id=user_integration.yellowant_integration_id)
player_object.playing_state = state
player_object.opponent_integration_id = opponent_object.yellowant_integration_id
opponent_object.opponent_integration_id = player_object.yellowant_integration_id
player_object.board_state = INITIAL_BOARD + INITIAL_BOARD_REST
opponent_object.board_state = INITIAL_BOARD + INITIAL_BOARD_REST
player_object.save()
opponent_object.save()
webhook_message = MessageClass()
webhook_message.message_text = "Chess Invite"
attachment = MessageAttachmentsClass()
field1 = AttachmentFieldsClass()
field1.title = "Your Chess Invite has been accepted by"
field1.value = player_object.yellowant_team_subdomain
button = MessageButtonsClass()
button.text = "Start Game"
button.value = "Start Game"
button.name = "Start Game"
button.command = {
"service_application" : str(opponent_object.yellowant_integration_id),
"function_name" : "startgameplayer",
"data" : {"user_int": player_object.yellowant_integration_id},
"inputs" : ["Color"]
}
attachment.attach_button(button)
attachment.attach_field(field1)
webhook_message.attach(attachment)
access_token = opponent_object.yellowant_integration_token
yellowant_user_integration_object = YellowAnt(access_token=access_token)
send_message = yellowant_user_integration_object.create_webhook_message(
requester_application=opponent_object.yellowant_integration_id,
webhook_name="webhook", **webhook_message.get_dict())
m = MessageClass()
return m
def incident_resolved(request, webhook_id):
#
data = request.body
data_string = data.decode('utf-8')
data_json = json.loads(data_string)
name = data_json['display_name']
entity_id = data_json['entity_id']
incident_number = data_json['incident_number']
# Fetching yellowant object
yellow_obj = YellowUserToken.objects.get(webhook_id=webhook_id)
access_token = yellow_obj.yellowant_token
integration_id = yellow_obj.yellowant_integration_id
service_application = str(integration_id)
# Creating message object for webhook message
webhook_message = MessageClass()
webhook_message.message_text = "Incident Resolved\n The entity ID : " + str(entity_id) \
+ "\nThe Incident Number : " + str(incident_number)
attachment = MessageAttachmentsClass()
attachment.title = "Incident Operations"
button_get_incidents = MessageButtonsClass()
button_get_incidents.name = "1"
button_get_incidents.value = "1"
button_get_incidents.text = "Get all incidents"
button_get_incidents.command = {
"service_application": service_application,
"function_name": 'list_incidents',
"data": {
'data': "test",
}
}
attachment.attach_button(button_get_incidents)
webhook_message.attach(attachment)
# print(integration_id)
webhook_message.data = {
"Display Name": name,
"Entity ID": entity_id,
"Incident Number": incident_number,
}
# Creating yellowant object
yellowant_user_integration_object = YellowAnt(access_token=access_token)
# Sending webhook message to user
yellowant_user_integration_object.create_webhook_message(
requester_application=integration_id,
webhook_name="new_incident_resolved",
**webhook_message.get_dict())
return HttpResponse("OK", status=200)
def Contact_Lists(self, args):
# List all the contact lists(groups) the user has created.
user_id = self.user_integration.yellowant_integration_id
url = (settings.SM_API_BASE + settings.VIEW_CONTACTLISTS)
try:
message = MessageClass()
message.message_text = "Contact list:\n"
attachment = MessageAttachmentsClass()
response = requests.get(url, headers=self.headers)
response_json = response.json()
data = response_json["data"]
send_data = {\
'list':[]\
}
for i in range(len(data)):
button1 = MessageButtonsClass()
obj = data[i]
name = obj["name"]
id = obj["id"]
send_data['list'].append({'id':id, 'name':name})
button1.text = name
button1.value = name
button1.name = name
button1.command = {
"service_application": user_id,
"function_name": "ContactListDetails",\
"data":{\
"ContactListId":id\
}
}
attachment.attach_button(button1)
message.attach(attachment)
message.data = 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("Exception occured is")
print(str(e))
traceback.print_exc()
def View_Surveys(self, args):
# Display the Surveys associated with the users account.
print("In view surveys")
user_id = self.user_integration.yellowant_intergration_id
url = (settings.SM_API_BASE + settings.VIEW_SURVEY)
response = requests.get(url, headers=self.headers)
response_json = response.json()
print(response_json)
data = response_json["data"]
send_data = {"surveys": []}
message = MessageClass()
message.message_text = "Surveys"
for i in range(len(data)):
attachment = MessageAttachmentsClass()
send_data['surveys'].append({
'id': data[i]["id"],
'title': data[i]["title"]
})
obj = data[i]
title = obj["title"]
id = obj["id"]
button1 = MessageButtonsClass()
attachment.title = title
field1 = AttachmentFieldsClass()
field1.title = "ID"
field1.value = id
attachment.attach_field(field1)
button1.text = "Know more"
button1.value = id
button1.name = id
button1.command = {
"service_application": user_id,
"function_name": "ViewSurveyDetails",
"data":{\
"SurveyId":id\
}
}
attachment.attach_button(button1)
message.attach(attachment)
message.data = send_data
print(message)
# use inbuilt sdk method to_json to return message in a json format accepted by YA
return message.to_json()
def list_view(self, args):
"""For viewing the account details"""
id = args['Id']
query = "api_key=" + self.API_Access_key + "&api_action=list_view&api_output=json&id="+id
url = (self.API_Access_URL + "/admin/api.php?" + query)
print(self.API_Access_URL)
print(url)
response = requests.get(url)
response_json = response.json()
print(response_json)
message = MessageClass()
message.message_text = "Account Details:"
attachment = MessageAttachmentsClass()
try:
field1 = AttachmentFieldsClass()
field1.title = "User ID"
field1.value = response_json['userid']
attachment.attach_field(field1)
field2 = AttachmentFieldsClass()
field2.title = "Name"
field2.value = response_json['name']
attachment.attach_field(field2)
attachment = MessageAttachmentsClass()
button2 = MessageButtonsClass()
button2.text = "Delete List"
button2.value = "Delete List"
button2.name = "Delete List"
button2.command = {"service_application": self.yellowant_integration_id,
"function_name": "list-delete",
"data": {"Id": args['Id']}}
attachment.attach_button(button2)
message.attach(attachment)
message.message_text = "The Details of the list are:"
except:
message.message_text = "The Given list Does not exist"
return message.to_json()
def playAgainst(args,user_integration):
"""
Function which sends the invite to other players to play chess.
"""
opponent_id = args.get("yellowant_user_id")
opponent_object = UserIntegration.objects.get(yellowant_integration_id=opponent_id)
player_object = UserIntegration.objects.get(yellowant_integration_id=user_integration.yellowant_integration_id)
webhook_message = MessageClass()
webhook_message.message_text = "Chess Invite"
attachment = MessageAttachmentsClass()
field1 = AttachmentFieldsClass()
field1.title = "You have been invited to play chess with "
field1.value = player_object.yellowant_team_subdomain
button = MessageButtonsClass()
button.text = "Accept Invitation"
button.value = "Accept Invitation"
button.name = "Accept Invitation"
button.command = {
"service_application": str(opponent_object.yellowant_integration_id),
"function_name": "accept",
"data": {"user_int": player_object.yellowant_integration_id }
}
attachment.attach_button(button)
attachment.attach_field(field1)
webhook_message.attach(attachment)
access_token = opponent_object.yellowant_integration_token
yellowant_user_integration_object = YellowAnt(access_token=access_token)
print("Printing webhook")
send_message = yellowant_user_integration_object.create_webhook_message(
requester_application=opponent_object.yellowant_integration_id,
webhook_name="webhook", **webhook_message.get_dict())
m = MessageClass()
m.message_text = "Waiting for response from opponent"
return m
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 showBoard(args,user_integration):
print(user_integration.yellowant_integration_id)
object = UserIntegration.objects.get(yellowant_integration_id=user_integration.yellowant_integration_id)
board = chess.Board(object.board_state)
print(object.board_state)
m = MessageClass()
m.message_text = color(object.board_state[-12]) + " to move"
attachment = MessageAttachmentsClass()
attachment.image_url = IMAGE_URL + board.fen()[:-13]
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)
m.attach(attachment)
return m
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 add_new_user(request, webhook_id):
"""
Webhook function to notify user about newly added user
"""
# Extracting necessary data
data = request.body
data_string = data.decode('utf-8')
data_json = json.loads(data_string)
ID = data_json["current"][0]['id']
name = data_json["current"][0]['name']
Default_currency = data_json["current"][0]['default_currency']
Email = data_json["current"][0]['email']
phone = "-" if data_json["current"][0]['phone'] is None else data_json[
"current"][0]['phone']
# Fetching yellowant object
yellow_obj = YellowUserToken.objects.get(webhook_id=webhook_id)
access_token = yellow_obj.yellowant_token
integration_id = yellow_obj.yellowant_integration_id
service_application = str(integration_id)
# Creating message object for webhook message
webhook_message = MessageClass()
webhook_message.message_text = "New user added."+"\n" + "The username : "******"\nThe Email ID:" + str(Email)
attachment = MessageAttachmentsClass()
attachment.title = "Get user details"
button_get_users = MessageButtonsClass()
button_get_users.name = "1"
button_get_users.value = "1"
button_get_users.text = "Get all users"
button_get_users.command = {
"service_application": service_application,
"function_name": 'list_users',
"data": {
'data': "test",
}
}
attachment.attach_button(button_get_users)
webhook_message.attach(attachment)
# print(integration_id)
# userinfo = response['data']
# phone = "-" if userinfo['phone'] is None else userinfo['phone']
webhook_message.data = {
"name": name,
"ID": ID,
"Email": Email,
"Phone": phone,
"Default currency": Default_currency
}
# 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="new_user",
**webhook_message.get_dict())
return HttpResponse("OK", status=200)
def webhook_unsubscribed(request, webhook_id):
print("In webhook_unsubscribed")
"""
Webhook function to notify user about update in unsbscribes
"""
urllib.parse.unquote(request.body.decode("utf-8"))
params_dict = urllib.parse.parse_qsl(request.body)
params = dict(params_dict)
## Extracting necessary data
device_type = params[b'device-type'].decode("utf-8")
name = params[b'client-name'].decode("utf-8")
domain = params[b'domain'].decode("utf-8")
city = params[b'city'].decode('utf-8')
country = params[b'country'].decode('utf-8')
recipient = params[b'recipient'].decode('utf-8')
try:
# Fetching yellowant object
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 = "Unsubscribe details"
attachment_message = MessageAttachmentsClass()
field2 = AttachmentFieldsClass()
field2.title = "Email Id :"
field2.value = recipient
attachment_message.attach_field(field2)
field1 = AttachmentFieldsClass()
field1.title = "Browser :"
field1.value = name
attachment_message.attach_field(field1)
field3 = AttachmentFieldsClass()
field3.title = "Domain"
field3.value = domain
attachment_message.attach_field(field3)
field4 = AttachmentFieldsClass()
field4.title = "Device type"
field4.value = device_type
attachment_message.attach_field(field4)
field5 = AttachmentFieldsClass()
field5.title = "City"
field5.value = city
attachment_message.attach_field(field5)
field6 = AttachmentFieldsClass()
field6.title = "Country"
field6.value = country
attachment_message.attach_field(field6)
webhook_message.attach(attachment_message)
attachment = MessageAttachmentsClass()
attachment.title = "Unsubscribe operations"
button_get_incidents = MessageButtonsClass()
button_get_incidents.name = "1"
button_get_incidents.value = "1"
button_get_incidents.text = "Get unsubscribe details"
button_get_incidents.command = {
"service_application": service_application,
"function_name": 'get_unsubscribes',
"data": {}
}
attachment.attach_button(button_get_incidents)
webhook_message.data = {
"recipient_email_id": recipient,
"domain": domain,
"device_type": device_type,
"city": city,
"country": country,
"name": name,
}
webhook_message.attach(attachment)
#print(integration_id)
# 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="notify_unsubscribe",
**webhook_message.get_dict())
return HttpResponse("OK", status=200)
except YellowUserToken.DoesNotExist:
return HttpResponse("Not Authorized", status=403)
def startGameAgainstPlayer(args,user_integration):
"""
"""
player_object = UserIntegration.objects.get(yellowant_integration_id=user_integration.yellowant_integration_id)
opponent_object = UserIntegration.objects.get(yellowant_integration_id=player_object.opponent_integration_id)
board = chess.Board(player_object.board_state)
color = args['Color']
attachment = MessageAttachmentsClass()
print(color + " to move")
if (color=="Black"):
webhook_message = MessageClass()
webhook_message.message_text = "You are playing White!"
attachment = MessageAttachmentsClass()
button = MessageButtonsClass()
button.text = "Make Move"
button.value = "Make Move"
button.name = "Make Move"
button.command = {
"service_application": str(opponent_object.yellowant_integration_id),
"function_name": "makemoveagainst",
"data": {"user_int": player_object.yellowant_integration_id},
}
attachment.attach_button(button)
webhook_message.attach(attachment)
access_token = opponent_object.yellowant_integration_token
yellowant_user_integration_object = YellowAnt(access_token=access_token)
send_message = yellowant_user_integration_object.create_webhook_message(
requester_application=opponent_object.yellowant_integration_id,
webhook_name="webhook", **webhook_message.get_dict())
return
else:
print("Inside else")
m = MessageClass()
attachment = MessageAttachmentsClass()
attachment.image_url = IMAGE_URL + INITIAL_BOARD
m.message_text = "Make a Move"
field1 = AttachmentFieldsClass()
field1.title = "Move"
field1.value = color + " to move"
attachment.attach_field(field1)
attachment.image_url = IMAGE_URL + INITIAL_BOARD
button = MessageButtonsClass()
button.text = "Make Move"
button.value = "Make Move"
button.name = "Make Move"
button.command = {
"service_application": str(player_object.yellowant_integration_id),
"function_name": "makemoveagainst",
"inputs": ["move"],
"data": {"user_int": player_object.yellowant_integration_id},
}
attachment.attach_button(button)
m.attach(attachment)
return m
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_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()
def webhook(request, hash_str=""):
print("Inside webhook")
data = request.body
if len(data) == 0:
validationToken = request.GET['validationtoken']
try:
print("In try")
return HttpResponse(validationToken, status=200)
except:
validationToken = None
print("Error occured")
return HttpResponse(status=400)
else:
try:
message = MessageClass()
attachment = MessageAttachmentsClass()
response_json = json.loads(data)
value_obj = response_json["value"]
value = value_obj[0]
SubscriptionId = value["SubscriptionId"]
ResourceData = value["ResourceData"]
message_id = ResourceData["Id"]
ya_user = YellowUserToken.objects.get(
subscription_id=SubscriptionId)
"""Make a request to get the message details using message_id"""
get_message_details = graph_endpoint.format(
"/me/messages/{}".format(message_id))
webhook_request = make_api_call('GET', get_message_details,
ya_user.outlook_access_token)
response_json = webhook_request.json()
subject = response_json["subject"]
from_user = response_json["from"]
email_address = from_user["emailAddress"]
attachment.title = "Subject"
attachment.text = str(subject)
message.attach(attachment)
forward_button = MessageButtonsClass()
forward_button.text = "Forward"
forward_button.value = "forward"
forward_button.name = "forward"
forward_button.command = {
"service_application": ya_user.yellowant_integration_id,
"function_name": "forward_message",
"data": {
"Message-Id": str(message_id)
},
"inputs": ["toRecipients", "Message"]
}
attachment.attach_button(forward_button)
reply_button = MessageButtonsClass()
reply_button.text = "Reply"
reply_button.value = "Reply"
reply_button.name = "Reply"
reply_button.command = {
"service_application": ya_user.yellowant_integration_id,
"function_name": "reply",
"data": {
"Message-Id": str(message_id)
},
"inputs": ["Message"]
}
attachment.attach_button(reply_button)
message.message_text = "Ola! You got a new E-mail from-" + email_address[
"name"] + "( " + email_address["address"] + " )"
yauser_integration_object = YellowAnt(
access_token=ya_user.yellowant_token)
print("Reached here")
yauser_integration_object.create_webhook_message(
requester_application=ya_user.yellowant_integration_id,
webhook_name="inbox_webhook",
**message.get_dict())
return True
except YellowUserToken.DoesNotExist:
return HttpResponse("Not Authorized", status=403)
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 list_users_today(self, args):
#Check if 'sort' param is present, else assign default as 'asc'
if 'sort' in args:
if args['sort'] in ['asc', 'dsc']:
order = args['sort']
else:
#If invalid, fallback to default value
order = 'asc'
else:
#setting default order 'asc'
order = 'asc'
if 'subscription' in args:
subscription = args['subscription']
else:
subscription = None
#Instantiate a Message Object
message = MessageClass()
message.message_text = ""
#Create list to store the results
users_list = []
d_24 = datetime.datetime.now() - datetime.timedelta(days=1)
if subscription is None:
users_today = SiteUsers.objects.filter(date_joined__gte=d_24)
else:
users_today = SiteUsers.objects.filter(date_joined__gte=d_24,
subscription=subscription)
#Creating User attachments with information of users with a button to fetch user details using the "list_user_details" command
for user in users_today:
user_attachment = MessageAttachmentsClass()
user_attachment.title = user.full_name
#Showing user data in a "Field"
date_field = AttachmentFieldsClass()
date_field.title = "Date Joined"
date_field.value = user.date_joined
date_field.short = 1 #Utilize two columns
user_attachment.attach_field(date_field)
#Adding a button which calls the "list_user_details" command
get_user_details_button = MessageButtonsClass()
get_user_details_button.value = "1" #Give some random value
get_user_details_button.name = "1" #Give some random value
get_user_details_button.text = "Get user details"
#Encoding command in button
get_user_details_button.command = {
"function_name": "list_user_details",
"service_application": self.service_application,
"data": {
"id": user.id
}
}
user_attachment.attach_button(get_user_details_button)
#Adding a button which provides with a dialog to change the subscription for the user using "change_user_subcription" function
change_user_sub_button = MessageButtonsClass()
change_user_sub_button.value = "1" #Give some random value
change_user_sub_button.name = "1" #Give some random value
change_user_sub_button.text = "Change subscription"
#Encoding command in button
change_user_sub_button.command = {
"function_name": "change_user_subcription",
"service_application": self.service_application,
"data": {
"id": user.id
},
"inputs": ['subscription']
}
user_attachment.attach_button(change_user_sub_button)
#Add attachment to message
message.attach(user_attachment)
#Adding users data to be used in workflows
message.data = {"users": serializers.serialize("json", users_today)}
return message.to_json()
def makeAMove(args,user_integration):
print('hello')
print(user_integration.yellowant_integration_id)
object = UserIntegration.objects.get(yellowant_integration_id=user_integration.yellowant_integration_id)
print(object.id)
print(object.board_state)
board = chess.Board(object.board_state)
print(board)
print(args)
move = args.get('move')
m = MessageClass()
print(object.board_state)
print(object.board_state[-12])
col = color_inv(object.board_state[-12])
print(col)
m.message_text = col + " to move"
move_uci = board.parse_san(move)
if move_uci in board.legal_moves:
board.push_san(move)
if board.is_insufficient_material():
print("Insufficient material")
m.message_text = "Insufficient material"
if board.is_stalemate():
print("Stalemate")
m.message_text = "Stalemate"
if board.is_checkmate():
print(col + " wins")
m.message_text = col + " wins"
object.board_state = board.fen()
object.save()
else:
m.message_text = "Invalid move"
return m
attachment = MessageAttachmentsClass()
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)
attachment.image_url = IMAGE_URL + board.fen()[:-13]
m.attach(attachment)
return m
def get_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')
instance = access_token_object.instance
url = " https://" + instance + ".service-now.com/api/now/table/incident/" + sys_id
response = requests.get(url=url, headers=headers)
message = MessageClass()
message.message_text = "The incident is"
attachment = MessageAttachmentsClass()
field1 = AttachmentFieldsClass()
field1.title = "Incident Name"
field1.value = response.json()["result"]["number"]
attachment.attach_field(field1)
field1 = AttachmentFieldsClass()
field1.title = "Created by"
field1.value = response.json()["result"]["sys_created_by"]
attachment.attach_field(field1)
field1 = AttachmentFieldsClass()
field1.title = "Incident State"
field1.value = response.json()["result"]["incident_state"]
attachment.attach_field(field1)
field1 = AttachmentFieldsClass()
field1.title = "Description"
field1.value = response.json()["result"]["description"]
attachment.attach_field(field1)
field1 = AttachmentFieldsClass()
field1.title = "Priority"
field1.value = response.json()["result"]["priority"]
attachment.attach_field(field1)
field1 = AttachmentFieldsClass()
field1.title = "Impact"
field1.value = response.json()["result"]["impact"]
attachment.attach_field(field1)
button = MessageButtonsClass()
button.text = "Modify State"
button.value = "Modify State"
button.name = "Modify State"
button.command = {
"service_application": str(user_integration.yellowant_integration_id),
"function_name": "modifystate",
"data": {
"sys_id": sys_id
},
"inputs": ["state"]
}
attachment.attach_button(button)
button = MessageButtonsClass()
button.text = "Change impact"
button.value = "Change impact"
button.name = "Change impact"
button.command = {
"service_application": str(user_integration.yellowant_integration_id),
"function_name": "changeimpact",
"data": {
"sys_id": sys_id
},
"inputs": ["impact"]
}
attachment.attach_button(button)
button1 = MessageButtonsClass()
button1.text = "Close Incident"
button1.value = "Close Incident"
button1.name = "Close Incident"
button1.command = {
"service_application": str(user_integration.yellowant_integration_id),
"function_name": "closeincident",
"data": {
"sys_id": sys_id
},
"inputs": ["close_notes", "close_code"]
}
attachment.attach_button(button1)
button2 = MessageButtonsClass()
button2.text = "Resolve Incident"
button2.value = "Resolve Incident"
button2.name = "Resolve Incident"
button2.command = {
"service_application": str(user_integration.yellowant_integration_id),
"function_name": "resolveincident",
"data": {
"sys_id": sys_id
},
"inputs": ["resolve_notes", "close_code"]
}
attachment.attach_button(button2)
button3 = MessageButtonsClass()
button3.text = "Change priority"
button3.value = "Change priority"
button3.name = "Change priority"
button3.command = {
"service_application": str(user_integration.yellowant_integration_id),
"function_name": "changepriority",
"data": {
"sys_id": sys_id
},
"inputs": ["priority"]
}
attachment.attach_button(button3)
message.attach(attachment)
return message
def makeMoveAgainst(args,user_integration):
player_object = UserIntegration.objects.get(yellowant_integration_id=user_integration.yellowant_integration_id)
opponent_object = UserIntegration.objects.get(yellowant_integration_id=player_object.opponent_integration_id)
access_token = opponent_object.yellowant_integration_token
yellowant_user_integration_object = YellowAnt(access_token=access_token)
move = args.get("move")
board = chess.Board(player_object.board_state)
col = color_inv(player_object.board_state[-12])
m = MessageClass()
m.message_text = col + " to move"
move_uci = board.parse_san(move)
if move_uci in board.legal_moves:
board.push_san(move)
if board.is_insufficient_material():
print("Insufficient material")
m.message_text = "Insufficient material"
endGame(args, user_integration)
webhook_message = MessageClass()
webhook_field = AttachmentFieldsClass()
webhook_field.title = "Result"
webhook_field.value = "Game drawn due to insufficient material"
attachmentImage = MessageAttachmentsClass()
attachmentImage.image_url = IMAGE_URL + board.fen()[:-13]
attachmentImage.attach_field(webhook_field)
webhook_message.attach(attachmentImage)
if board.is_stalemate():
print("Stalemate")
m.message_text = "Stalemate"
endGame(args, user_integration)
if board.is_checkmate():
print(col + " wins")
m.message_text = col + " wins"
endGame(args, user_integration)
player_object.board_state = board.fen()
opponent_object.board_state = board.fen()
player_object.save()
opponent_object.save()
else:
m.message_text = "Invalid move"
return m
attachment = MessageAttachmentsClass()
attachment.image_url = IMAGE_URL + board.fen()[:-13]
m.attach(attachment)
webhook_message = MessageClass()
webhook_field = AttachmentFieldsClass()
webhook_field.title = "Move"
webhook_field.value = col + " to move"
attachmentImage = MessageAttachmentsClass()
attachmentImage.attach_field(webhook_field)
attachmentImage.image_url = IMAGE_URL + board.fen()[:-13]
button = MessageButtonsClass()
button.text = "Make Move"
button.value = "Make Move"
button.name = "Make Move"
button.command = {
"service_application": str(opponent_object.yellowant_integration_id),
"function_name": "makemoveagainst",
"inputs": ["move"],
"data": {"user_int": player_object.yellowant_integration_id},
}
attachmentImage.attach_button(button)
webhook_message.attach(attachmentImage)
send_message = yellowant_user_integration_object.create_webhook_message(
requester_application=opponent_object.yellowant_integration_id,
webhook_name="webhook", **webhook_message.get_dict())
return m
def list_function(self, args):
""" Gives the list of the functions in the Lambda"""
message = MessageClass()
attachment = MessageAttachmentsClass()
region = args['Region']
# Page is an optional argument
try:
page = int(args["Page"])
except:
page = 1
# If page no. is greater than 1 get the marker of the specified field and use it to get the functions in that page
if page > 1:
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)
#Snippet added to check the Page No. entered is valid or not
check = aws_lambda.get_account_settings()
max_page = int(int(check['AccountUsage']['FunctionCount'])/10)+1
# If page no. entered is greter than max pages of the Lambda then return this
if page > max_page:
message.message_text = "The Page no. entered is more than the pages present"
return message.to_json()
next_marker = self.marker(args, page)
response = aws_lambda.list_functions(Marker=next_marker, MaxItems=10)
functions = [Function['FunctionName'] for Function in response['Functions']]
# Attaching functions and thier respective Buttons
for Function in functions:
attachment = MessageAttachmentsClass()
attachment.title = Function
message.attach(attachment)
# 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": {"FunctionName": Function, "Region": region},
"inputs": ["input"]}
attachment.attach_button(button1)
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.message_text = ("The Functions in Page %d are:" % page)
except:
message.message_text = "This is the last page"
# If page is 1 or not specified than return the functions in the 1st page
else:
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)
# Display first 10 functions
response = aws_lambda.list_functions(MaxItems=10)
functions = [Function['FunctionName'] for Function in response['Functions']]
for Function in functions:
attachment = MessageAttachmentsClass()
attachment.title = Function
message.attach(attachment)
# 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)
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.message_text = ("The Functions in Page %d are:" % page)
except:
message.message_text = "This is the last page"
return message.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 add_new_customer(request, webhook_id):
"""
Webhook function to notify user about newly created customer
"""
print("In add_new_customer")
print(webhook_id)
# Extracting necessary data
code = request.GET.get("code", False)
if code == request.codes.ok:
data = (request.body.decode('utf-8'))
response_json = json.loads(data)
print(response_json)
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
#QuickbookUserToken.objects.get(realmId=response_json['eventNotifications'][0]['realmId']).user_integration_id
service_application = str(integration_id)
print(service_application)
# Creating message object for webhook message
webhook_message = MessageClass()
id = str(response_json['eventNotifications'][0]['dataChangeEvent']
['entities'][0]['id'])
webhook_message.message_text = "New customer added\n" + "ID :" + str(
response_json['eventNotifications'][0]['dataChangeEvent']
['entities'][0]['id'])
attachment = MessageAttachmentsClass()
attachment.title = "Get all customer details"
button_get_incidents = MessageButtonsClass()
button_get_incidents.name = "1"
button_get_incidents.value = "1"
button_get_incidents.text = "Get customer details"
button_get_incidents.command = {
"service_application": service_application,
"function_name": 'get_customer_details',
"data": {
"customer_id": id
}
}
attachment.attach_button(button_get_incidents)
webhook_message.data = {"customer_id": id}
webhook_message.attach(attachment)
#print(integration_id)
# 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="new_customer",
**webhook_message.get_dict())
return HttpResponse("OK", status=200)
except YellowUserToken.DoesNotExist:
return HttpResponse("Not Authorized", status=403)
else:
return HttpResponse(status=400)
def add_new_deal(request, webhook_id):
"""
Webhook function to notify user about newly added deal
"""
# Extracting necessary data
data = request.body
data_string = data.decode('utf-8')
data_json = json.loads(data_string)
title = data_json["current"]['title']
handled_by = data_json["current"]['owner_name']
name = data_json["current"]['person_name']
currency = data_json["current"]['currency']
company = data_json["current"]['org_name']
value = data_json["current"]['value']
deal_email = data_json["current"]['cc_email']
# Fetching yellowant object
yellow_obj = YellowUserToken.objects.get(webhook_id=webhook_id)
access_token = yellow_obj.yellowant_token
integration_id = yellow_obj.yellowant_integration_id
service_application = str(integration_id)
# Creating message object for webhook message
webhook_message = MessageClass()
webhook_message.message_text = "New deal created."+"\n" + "The deal name : " + str(title) + "\nThe deal value:" \
+ str(currency)+" "+str(value)
attachment = MessageAttachmentsClass()
button_get_deal = MessageButtonsClass()
button_get_deal.name = "1"
button_get_deal.value = "1"
button_get_deal.text = "Get all deals"
button_get_deal.command = {
"service_application": service_application,
"function_name": 'list_all_deals',
"data": {
'data': "test",
}
}
attachment.attach_button(button_get_deal)
webhook_message.attach(attachment)
# print(integration_id)
webhook_message.data = {
"Handled by": handled_by,
"Name": name,
"Title": title,
"Company": company,
"Value": value,
"Currency": currency,
"Deal_email": deal_email
}
# 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="new_deal",
**webhook_message.get_dict())
return HttpResponse("OK", status=200)
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 add_new_activity(request, webhook_id):
"""
Webhook function to notify user about newly added pipeline
"""
data = request.body
data_string = data.decode('utf-8')
data_json = json.loads(data_string)
title = data_json["current"]['deal_title']
handled_by = data_json["current"]['owner_name']
name = data_json["current"]['person_name']
company = data_json["current"]['org_name']
deal_email = data_json["current"]['deal_dropbox_bcc']
activity_type = data_json["current"]['type']
due_date = data_json["current"]['due_date']
# Fetching yellowant object
yellow_obj = YellowUserToken.objects.get(webhook_id=webhook_id)
access_token = yellow_obj.yellowant_token
integration_id = yellow_obj.yellowant_integration_id
service_application = str(integration_id)
# Creating message object for webhook message
webhook_message = MessageClass()
webhook_message.message_text = "New activity added."+"\n" + "The deal name : " + str(title) + "\nThe activity date:" \
+ str(due_date)
attachment = MessageAttachmentsClass()
button_get_activity = MessageButtonsClass()
button_get_activity.name = "1"
button_get_activity.value = "1"
button_get_activity.text = "Get all activities"
button_get_activity.command = {
"service_application": service_application,
"function_name": 'list_activities',
"data": {
'data': "test",
}
}
attachment.attach_button(button_get_activity)
webhook_message.attach(attachment)
# print(integration_id)
webhook_message.data = {
"Handled by": handled_by,
"Contact Person": name,
"Due Date": due_date,
"Deal Title": title,
"Activity Type": activity_type,
"Company": company,
"Deal_email": deal_email
}
# 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="new_activity",
**webhook_message.get_dict())
return HttpResponse("OK", status=200)
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()
def playComputer(args,user_integration):
"""
Function to play against the Computer.
"""
object = UserIntegration.objects.get(yellowant_integration_id=user_integration.yellowant_integration_id)
board = chess.Board(object.board_state)
dir_path = os.path.dirname(os.path.realpath(__file__))
print(dir_path)
engine = chess.uci.popen_engine("/app/stockfish/Linux/stockfish-9")
#engine = chess.uci.popen_engine("/app/Stockfish-master/src/stockfish")
col = color(object.board_state[-12])
engine.position(board)
move = engine.go(movetime=2000)
board.push(chess.Move.from_uci(str(move[0])))
m = MessageClass()
if board.is_insufficient_material():
print("Insufficient material")
m.message_text = "Insufficient material"
return m
if board.is_stalemate():
print("Stalemate")
m.message_text = "Stalemate"
if board.is_checkmate():
print("Computer wins")
m.message_text = "Checkmate !! \n"+col + " wins"
return m
object.board_state = board.fen()
object.save()
attachment = MessageAttachmentsClass()
print(IMAGE_URL + board.fen()[:-13])
attachment.image_url = IMAGE_URL + board.fen()[:-13]
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)
button2 = MessageButtonsClass()
button2.text = "Accept Invitation"
button2.value = "Accept Invitation"
button2.name = "Accept Invitation"
button2.command = {
"service_application" : str(user_integration.yellowant_integration_id),
"function_name" : "accept",
"data" : {"user_int": user_integration.yellowant_integration_id }
}
attachment.attach_button(button2)
m.attach(attachment)
return m
def fetch_all_employees(args, user_integration):
print(user_integration.yellowant_integration_id)
print("user", user_integration.id)
auth_token_object = UserIntegration.objects.get(
yellowant_integration_id=user_integration.yellowant_integration_id)
auth_token = auth_token_object.auth_token
data = {'list': []}
url = "https://people.zoho.com/people/api/forms/P_EmployeeView/records?authtoken=" + auth_token
response = requests.post(url)
response = response.json()
m = MessageClass()
for employee in response:
attachment = MessageAttachmentsClass()
for k, v in employee.items():
if k == "First Name":
field1 = AttachmentFieldsClass()
field1.title = "First Name"
field1.value = v
attachment.attach_field(field1)
first_name = v
if k == "Last Name":
field2 = AttachmentFieldsClass()
field2.title = "Last Name"
field2.value = v
attachment.attach_field(field2)
last_name = v
if k == "EmployeeID":
field3 = AttachmentFieldsClass()
field3.title = "EmployeeID"
field3.value = v
attachment.attach_field(field3)
employee_id = v
if k == "recordId":
record_id = v
button = MessageButtonsClass()
button.text = "Get details"
button.value = "Get details"
button.name = "Get details"
button.command = {
"service_application":
str(user_integration.yellowant_integration_id),
"function_name": "getemployee",
"data": {
"employee_id": employee_id
},
}
attachment.attach_button(button)
data['list'].append({
"record_id": record_id,
"employee_id": employee_id,
"employee_name": first_name + " " + last_name
})
m.data = data
m.attach(attachment)
m.message_text = "Employee details are:"
return m
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()
