def ack_incidents(self, args): """ This acknowledges an incident or a list of incidents. """ message = MessageClass() url = settings.VICTOROPS_ACK_INCIDENTS # If there are multiple incidents they are split and added to an array incident_list = args['Incident-Numbers'].split(',') body = { "userName": self.victor_ops_uid, "incidentNames": incident_list, "message": args['Acknowledgement-Message'] } # PATCH request to victorops server response = requests.patch(url, headers=self.headers, data=json.dumps(body)) r_text = response.text if re.search(r'Already', r_text, re.M | re.I): attachment = MessageAttachmentsClass() attachment.text = "The incident is already resolved" message.attach(attachment) return message.to_json() elif re.search(r'User not found', r_text, re.M | re.I): attachment = MessageAttachmentsClass() attachment.text = "User not found" message.attach(attachment) return message.to_json() else: attachment = MessageAttachmentsClass() attachment.text = "Acknowledged!" message.attach(attachment) return message.to_json()
def resolve_incidents(self, args): """ This resolves an incident or a list of incidents. """ message = MessageClass() url = settings.VICTOROPS_RESOLVE_INCIDENTS incident_list = args['Incident-Numbers'].split(',') body = { "userName": self.victor_ops_uid, "incidentNames": incident_list, "message": args['Resolution-Message'] } # PATCH request to victorops server response = requests.patch(url, headers=self.headers, data=json.dumps(body)) r_text = response.text if re.search(r'Already', r_text, re.M | re.I): attachment = MessageAttachmentsClass() attachment.text = "The incident is already resolved" message.attach(attachment) return message.to_json() elif re.search(r'User not found', r_text, re.M | re.I): attachment = MessageAttachmentsClass() attachment.text = "User not found" message.attach(attachment) return message.to_json() else: attachment = MessageAttachmentsClass() attachment.text = "Resolved!" message.attach(attachment) return message.to_json()
def resolve_all_incidents(self, args): """ This resolves all the incidents the user was paged for. """ message = MessageClass() url = settings.VICTOROPS_RESOLVE_ALL_INCIDENTS body = { "userName": self.victor_ops_uid, "message": args['Resolution-Message'] } # PATCH request to victorops server response = requests.patch(url, headers=self.headers, data=json.dumps(body)) r_text = response.text if re.search(r'User not found', r_text, re.M | re.I): attachment = MessageAttachmentsClass() attachment.text = "User not found" message.attach(attachment) return message.to_json() else: attachment = MessageAttachmentsClass() attachment.text = "Resolved all the incidents!" message.attach(attachment) return message.to_json()
def create_incident(self, args): """ Creates a new incident given the incident body, description and the user to be paged for the incident A flag is also returned which denotes the success or the failure of incident creation which is used to provide a webhook. """ url = settings.VICTOROPS_CREATE_LIST_INCIDENT # Check if the user to be paged exists if self.test_get_user(args['Send-To']) == 0: message = MessageClass() attachment = MessageAttachmentsClass() attachment.text = "User not found!" message.attach(attachment) return message.to_json() else: body = { "summary": args['Incident-Summary'], "details": args['Incident-Body'], "userName": self.victor_ops_uid, "targets": [{ "type": "User", "slug": args['Send-To'] }] } response = requests.post(url, headers=self.headers, data=json.dumps(body)) message = MessageClass() attachment = MessageAttachmentsClass() attachment.text = "Incident created " r_text = response.text print(r_text) # A regex check to find the incident number of the new incident incident_nos = re.findall("\d+", r_text) # print(incident_nos) # print(incident_nos[0]) entity_id, vo_uuid = self.test_list_incidents(incident_nos[0]) field2 = AttachmentFieldsClass() field2.title = "Entity ID" field2.value = entity_id # print(field2.value) attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "VO_UUID" field3.value = vo_uuid attachment.attach_field(field3) message.attach(attachment) return message.to_json()
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 list_items(self, args): """ This function returns all the items of an organization """ org_id = args['organization'] headers = { "Authorization": "Zoho-oauthtoken" + " " + self.zohoinvoice_access_token, "X-com-zoho-invoice-organizationid": org_id, "Content-Type": "application/json" } url = settings.ZOHO_ITEMS_URL response = requests.get(url, headers=headers) print(response) print(response.text) message = MessageClass() message.message_text = "Items" response_json = response.json() data = response_json['items'] i = 0 print(data[0]['description']) a = data[0]['description'] if len(a) == 0: print("its none") else: print("no") for item in data: attachment = MessageAttachmentsClass() attachment.text = "Item" + " " + str(i + 1) field1 = AttachmentFieldsClass() field1.title = "Item Name" field1.value = item['name'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Item ID" field2.value = item['item_id'] attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Item Type" field3.value = item['product_type'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Rate" field4.value = item['rate'] attachment.attach_field(field4) des = item['description'] field5 = AttachmentFieldsClass() field5.title = "Description" field5.value = "-" if len(des) == 0 else des attachment.attach_field(field5) i = i + 1 message.attach(attachment) return message.to_json()
def create_invoice(self, args): """ This function is used to create an invoice given the org ID, customer ID,date, Item ID and the quantity """ org_id = args['organization'] customer_id = args['customer_id'] date = args['date'] item_id = args['item_id'] quantity = args['quantity'] # org_id = "669665442" # customer_id = "1392605000000069001" # date = "2018-07-27" # item_id = "1392605000000072001" # quantity = 1 headers = { "Authorization": "Zoho-oauthtoken" + " " + self.zohoinvoice_access_token, "X-com-zoho-invoice-organizationid": org_id, "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8" } url = settings.ZOHO_INVOICE_URL payload = { "customer_id": customer_id, "date": date, "line_items": [{ "item_id": item_id, "quantity": quantity, }], } response = requests.post(url, headers=headers, data={"JSONString": json.dumps(payload)}) response_json = response.json() print(response) print(response_json) message = MessageClass() if response.status_code == 400: attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Error" field1.value = response_json['message'] attachment.attach_field(field1) message.attach(attachment) return message.to_json() else: attachment = MessageAttachmentsClass() attachment.text = "Invoice created" message.attach(attachment) return message.to_json()
def list_users(self, args): """ Returns data about all users within the company """ url = settings.PIPEDRIVE_LIST_ADD_USERS_URL + self.pipedrive_api_token response = requests.get(url, headers=self.headers) response_json = response.json() # print(response_json) message = MessageClass() message.message_text = "Users" if not bool(response_json): attachment = MessageAttachmentsClass() attachment.text = "No users!" message.attach(attachment) return message.to_json() else: userinfo = response_json['data'] for user in userinfo: attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Name" field1.value = user['name'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "ID" field2.value = user['id'] attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Email" field3.value = user['email'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Phone" field4.value = "-" if user['phone'] is None else user['phone'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Default currency" field5.value = user['default_currency'] attachment.attach_field(field5) field6 = AttachmentFieldsClass() field6.title = "Admin" field6.value = 'True' if user['is_admin'] else 'False' attachment.attach_field(field6) message.attach(attachment) return message.to_json()
def list_activities(self, args): """ Returns all activities assigned to a particular user """ url = settings.PIPEDRIVE_GET_ALL_ACTIVITY + self.pipedrive_api_token response = requests.get(url, headers=self.headers) response_json = response.json() # print(response_json) activity_info = response_json['data'] message = MessageClass() message.message_text = "Activities" for i in range(len(activity_info)): attachment = MessageAttachmentsClass() attachment.text = "Activity" + " " + str(i + 1) field1 = AttachmentFieldsClass() field1.title = "Activity Subject" field1.value = activity_info[i]['subject'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Activity Type" field2.value = activity_info[i]['type'] attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Due Date" field3.value = activity_info[i]['due_date'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Contact Person" field4.value = "-" if activity_info[i][ 'person_name'] is None else activity_info[i]['person_name'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Company" field5.value = "-" if activity_info[i][ 'org_name'] is None else activity_info[i]['org_name'] attachment.attach_field(field5) field6 = AttachmentFieldsClass() field6.title = "Handled by" field6.value = activity_info[i]['owner_name'] attachment.attach_field(field6) message.attach(attachment) return message.to_json()
def list_all_deals(self, args): """ Returns all deals """ url = settings.PIPEDRIVE_GET_ALL_DEAL + self.pipedrive_api_token response = requests.get(url, headers=self.headers) response_json = response.json() # print(response_json) deal_info = response_json['data'] message = MessageClass() message.message_text = "Deals" for i in range(len(deal_info)): attachment = MessageAttachmentsClass() attachment.text = "Deal" + " " + str(i + 1) field1 = AttachmentFieldsClass() field1.title = "Title" field1.value = deal_info[i]['title'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Value" field2.value = str(deal_info[i]['currency']) + " " + str( deal_info[i]['value']) attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Name" field3.value = deal_info[i]['person_id']['name'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Company" field4.value = deal_info[i]['org_id']['name'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Handled by" field5.value = deal_info[i]['user_id']['name'] attachment.attach_field(field5) field6 = AttachmentFieldsClass() field6.title = "Status" field6.value = deal_info[i]['status'] attachment.attach_field(field6) message.attach(attachment) return message.to_json()
def list_incidents(self, args): """ This functions returns the list of the currently open, acknowledged and recently resolved incidents. """ url = settings.VICTOROPS_CREATE_LIST_INCIDENT response = requests.get(url, headers=self.headers) response_json = response.json() print(response_json) data = response_json["incidents"] # response_json = response_json.json() message = MessageClass() message.message_text = "All incidents : " # Check if there are incidents present if not bool(response_json): attachment = MessageAttachmentsClass() attachment.text = "No incidents" message.attach(attachment) return message.to_json() else: for details in data: attachment = MessageAttachmentsClass() field2 = AttachmentFieldsClass() field2.title = "Incident Number" field2.value = details["incidentNumber"] # print(field2.value) attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Current Phase" field3.value = details["currentPhase"] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Entity ID" field4.value = details["entityId"] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "VO_UUID" field5.value = details["lastAlertId"] attachment.attach_field(field5) message.attach(attachment) return message.to_json()
def list_users(self, args): """ Gives information about the users of the organization """ url = settings.VICTOROPS_ALL_USERS response = requests.get(url, headers=self.headers) response_json = response.json() # print(response_json) message = MessageClass() message.message_text = "Users" if not bool(response_json): attachment = MessageAttachmentsClass() attachment.text = "No users!" message.attach(attachment) return message.to_json() else: data = response_json['users'][0] for i in range(len(data)): attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Username" field1.value = data[i]['username'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Name" field2.value = str(data[i]['firstName']) + " " + str( data[i]['lastName']) attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Email" field3.value = data[i]['email'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Password Last Updated" field4.value = data[i]['passwordLastUpdated'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Verified" field5.value = data[i]['verified'] attachment.attach_field(field5) message.attach(attachment) return message.to_json()
def add_user(self, args): """ Adds a new user to the organization """ message = MessageClass() url = settings.VICTOROPS_ADD_USER body = { "firstName": args['First-Name'], "lastName": args['Last-Name'], "username": args['UserName'], "email": args['Email'], "admin": True, "expirationHours": int(args['Expiration-Hours']) } # POST request to victorops server response = requests.post(url, headers=self.headers, data=json.dumps(body)) # print(r) r_text = response.text if re.search(r'The email address', r_text, re.M | re.I): attachment = MessageAttachmentsClass() attachment.text = "The email is already registered" message.attach(attachment) return message.to_json() elif re.search(r'is unavailable', r_text, re.M | re.I): attachment = MessageAttachmentsClass() attachment.text = "Username " + str( args['UserName']) + " is not available" message.attach(attachment) return message.to_json() else: attachment = MessageAttachmentsClass() attachment.text = "User added" message.attach(attachment) return message.to_json()
def list_users(self, args): """ This function returns all the users in the organization """ org_id = args['organization'] headers = { "Content-Type": "application/json", "Authorization": "Zoho-oauthtoken" + " " + self.zohoinvoice_access_token, "X-com-zoho-invoice-organizationid": org_id } url = settings.ZOHO_USER_URL response = requests.get(url, headers=headers) print(response) print(response.text) i = 0 message = MessageClass() message.message_text = "Users" response_json = response.json() data = response_json['users'] for user in data: attachment = MessageAttachmentsClass() attachment.image_url = user["photo_url"] attachment.text = "User" + " " + str(i + 1) field1 = AttachmentFieldsClass() field1.title = "Name" field1.value = user['name'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Email" field2.value = user['email'] attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "User ID" field3.value = user['user_id'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Role ID" field4.value = user['role_id'] attachment.attach_field(field4) i = i + 1 message.attach(attachment) return message.to_json()
def get_user(self, args): """ This function is used to get the user details given the victorops user id """ user = args['User-ID'] # VictorOps user ID url = settings.VICTOROPS_GET_USER + str(user) response = requests.get(url, headers=self.headers) response_json = response.json() message = MessageClass() message.message_text = "User Details" if bool(response_json) == False: attachment = MessageAttachmentsClass() attachment.text = "No user found!" message.attach(attachment) return message.to_json() else: attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Username" field1.value = response_json['username'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Name" field2.value = str(response_json['firstName']) + " " + str( response_json['lastName']) attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Email" field3.value = response_json['email'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Password Last Updated" field4.value = response_json['passwordLastUpdated'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Verified" field5.value = response_json['verified'] attachment.attach_field(field5) message.attach(attachment) return message.to_json()
def get_logs(self, args): """To get the logs of the function""" region = args['Region'] function_name = args['FunctionName'] message = MessageClass() attachment = MessageAttachmentsClass() logstream = self.log_stream(args, function_name) # If Logstream is 0 then the Logs dosen't exist if logstream ==0: message.message_text = "There are no logs for that Function or the Log" \ " group name and the Function Name are mismatched" return message.to_json() aws_lambda = boto3.client(service_name='logs', 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) log_group_name = "/aws/lambda/"+function_name # The following while loop is to find the i till which last log exists, for usage in get_log_events i = 0 strin="" while strin != "START": response = aws_lambda.get_log_events( logGroupName=log_group_name, logStreamName=logstream, limit=i+1 ) string=str(response['events'][0]['message']) i = i+1 strin = string[:5] # response = aws_lambda.get_log_events( logGroupName=log_group_name, logStreamName=logstream, limit=i ) events = [event['message'] for event in response['events']] for event in events: attachment.text = event message.attach(attachment) message.message_text = "The Event logs are:" return message.to_json()
def add_user(self, args): """ This function is used to add an user to the organization """ org_id = args['organization'] name = args['name'] email = args['email'] role = args['user_role'] headers = { "Authorization": "Zoho-oauthtoken" + " " + self.zohoinvoice_access_token, "X-com-zoho-invoice-organizationid": org_id, "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8" } url = settings.ZOHO_USER_URL payload = {"name": name, "email": email, "user_role": role} response = requests.post(url, headers=headers, data={"JSONString": json.dumps(payload)}) response_json = response.json() print(response) print(response_json) message = MessageClass() if response.status_code == 400: attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Error" field1.value = response_json['message'] attachment.attach_field(field1) message.attach(attachment) return message.to_json() else: attachment = MessageAttachmentsClass() attachment.text = "Your invitation has been sent." message.attach(attachment) return message.to_json()
def Survey_Category(self, args): url = (settings.SM_API_BASE + settings.SURVEY_CATEGORY) response = requests.get(url, headers=self.headers) response_json = response.json() result = "Survey Categories are: \n" message = MessageClass() data = response_json["data"] for i in range(len(data)): obj = data[i] id = obj["id"] name = obj["name"] attachment = MessageAttachmentsClass() attachment.title = id attachment.text = name message.attach(attachment) message.message_text = "Categories are" # use inbuilt sdk method to_json to return message in a json format accepted by YA return message.to_json()
def list_pipelines(self, args): """ Returns data about all pipelines """ url = settings.PIPEDRIVE_GET_ADD_PIPELINE + self.pipedrive_api_token response = requests.get(url, headers=self.headers) response_json = response.json() # print(response_json) pipeline_info = response_json['data'] # print(deal_info) message = MessageClass() message.message_text = "Pipelines" for i in range(len(pipeline_info)): attachment = MessageAttachmentsClass() attachment.text = "Pipeline" + " " + str(i + 1) field1 = AttachmentFieldsClass() field1.title = "Name" field1.value = pipeline_info[i]['name'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Url title" field2.value = pipeline_info[i]['url_title'] attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Add Time" field3.value = pipeline_info[i]['add_time'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Order" field4.value = pipeline_info[i]['order_nr'] attachment.attach_field(field4) message.attach(attachment) return message.to_json()
def add_user(self, args): """ Adds a new user to the company, returns the ID upon success. """ message = MessageClass() url = settings.PIPEDRIVE_LIST_ADD_USERS_URL + self.pipedrive_api_token body = { "name": args['Name'], "email": args['Email'], "active_flag": "1" } # POST request to pipedrive server response = requests.post(url, headers=self.headers, data=json.dumps(body)) if response.status_code == 400: attachment = MessageAttachmentsClass() attachment.text = "Provided email not valid" message.attach(attachment) return message.to_json() else: response_json = response.json() # print(response_json) userinfo = response_json['data'] # print(userinfo) message.message_text = "User Added!" attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Name" field1.value = userinfo['name'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "ID" field2.value = userinfo['id'] attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Email" field3.value = userinfo['email'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Phone" field4.value = "-" if userinfo['phone'] is None else userinfo[ 'phone'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Default currency" field5.value = userinfo['default_currency'] attachment.attach_field(field5) field6 = AttachmentFieldsClass() field6.title = "Admin" field6.value = 'True' if userinfo['is_admin'] else 'False' attachment.attach_field(field6) phone = "-" if userinfo['phone'] is None else userinfo['phone'] message.data = { "name": userinfo['name'], "ID": userinfo['id'], "Email": userinfo['email'], "Phone": phone, "Default currency": userinfo['default_currency'] } message.attach(attachment) return message.to_json()
def search_users(self, args): """ Finds users by their name.The input must be at least 2 characters long. """ message = MessageClass() if (len(args['Search-Term'])) < 2: attachment = MessageAttachmentsClass() attachment.text = "The search term must be at least 2 characters long" message.attach(attachment) return message.to_json() url = settings.PIPEDRIVE_SEARCH_USERS_URL % args[ 'Search-Term'] + self.pipedrive_api_token # print(url) body = {"term": args['Search-Term']} response = requests.get(url, headers=self.headers, data=json.dumps(body)) response_json = response.json() # print(response_json) message.message_text = "Users" userinfo = response_json['data'] if userinfo is None: attachment = MessageAttachmentsClass() attachment.text = "No users found!" message.attach(attachment) return message.to_json() else: for user in userinfo: attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Name" field1.value = user['name'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "ID" field2.value = user['id'] attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Email" field3.value = user['email'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Phone" field4.value = "-" if user['phone'] is None else user['phone'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Default currency" field5.value = user['default_currency'] attachment.attach_field(field5) field6 = AttachmentFieldsClass() field6.title = "Admin" field6.value = 'True' if user['is_admin'] else 'False' attachment.attach_field(field6) message.attach(attachment) return message.to_json()
def get_message_byfolder(self, args): """This function returns the messages of a particular folder. The name of the folder is provided as input by the user. If the folder is Empty it returns 'Empty Folder' """ print("In get_message_byfolder") folder_name = args["Folder-Name"] folder_name = folder_name.strip() folder_name = folder_name.replace(" ", "") get_foldermessages_url = graph_endpoint.format( '/me/mailfolders/{}/messages'.format(folder_name)) query_parameters = { '$top': '10', '$select': 'receivedDateTime,subject,from', '$orderby': 'receivedDateTime DESC' } r = make_api_call('GET', get_foldermessages_url, self.access_token, parameters=query_parameters) print(r.json()) value = r.json()["value"] message = MessageClass() if len(value) == 0: message.message_text = "Empty Folder" return message.to_json() if r.status_code == requests.codes.ok: for i in range(0, len(value)): obj = value[i] id = obj["id"] bodyPreview = self.list_messages(args, id=id) attachment = MessageAttachmentsClass() attachment.title = "Subject" attachment.text = str(obj["subject"]) field1 = AttachmentFieldsClass() field1.title = "Received Date Time" field1.value = str(obj["receivedDateTime"]) attachment.attach_field(field1) if bodyPreview != None: field2 = AttachmentFieldsClass() field2.title = "Body Preview" field2.value = str(bodyPreview) attachment.attach_field(field2) from_obj = obj["from"] for j in range(0, len(from_obj)): emailAddress = from_obj["emailAddress"] field3 = AttachmentFieldsClass() field3.title = "From" field3.value = emailAddress["name"] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Email Id" field4.value = emailAddress["address"] attachment.attach_field(field4) message.attach(attachment) message.message_text = "messages are" print("returning mailfolder") if i == (len(value) - 1): return message.to_json() else: continue else: print(r.text) return "{0}: {1}".format(r.status_code, r.text)
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 add_activity(self, args): """ Adds a new activity. """ url = settings.PIPEDRIVE_ADD_ACTIVITY + self.pipedrive_api_token body = { "subject": args['Subject'], "done": "0", "type": args['Type'], "due_date": args['Due-Date'], "deal_id": args['Deal'], "person_id": args['Contact-Person'] } response = requests.post(url, headers=self.headers, data=json.dumps(body)) # print(response) # print(response_json) message = MessageClass() if response.status_code == 400: attachment = MessageAttachmentsClass() attachment.text = "Unrecognized date value for due date." message.attach(attachment) return message.to_json() else: response_json = response.json() activity_info = response_json['data'] message.message_text = "Activity added" attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Activity Subject" field1.value = activity_info['subject'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Activity Type" field2.value = activity_info['type'] attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Due Date" field3.value = activity_info['due_date'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Contact Person" field4.value = activity_info['person_name'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Company" field5.value = activity_info['org_name'] attachment.attach_field(field5) field6 = AttachmentFieldsClass() field6.title = "Handled by" field6.value = activity_info['owner_name'] attachment.attach_field(field6) message.data = { "Activity Subject": activity_info['subject'], "Activity Type": activity_info['type'], "Due Date": activity_info['due_date'], "Contact Person": activity_info['person_name'], "Company": activity_info['org_name'], "Handled by": activity_info['owner_name'] } message.attach(attachment) return message.to_json()
def add_pipeline(self, args): """ Adds a new pipeline """ url = settings.PIPEDRIVE_GET_ADD_PIPELINE + self.pipedrive_api_token body = { "name": args['Name'], "deal_probability": args['Deal-Probability'], "active": "1" } response = requests.post(url, headers=self.headers, data=json.dumps(body)) # print(response.text) message = MessageClass() if response.status_code == 400: attachment = MessageAttachmentsClass() attachment.text = "Cannot add the pipeline." message.attach(attachment) return message.to_json() else: response_json = response.json() pipeline_info = response_json['data'] message.message_text = "Pipeline created" attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Name" field1.value = pipeline_info['name'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Url title" field2.value = pipeline_info['url_title'] attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Add Time" field3.value = pipeline_info['add_time'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Order" field4.value = pipeline_info['order_nr'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Deal Probability" field5.value = pipeline_info['deal_probability'] attachment.attach_field(field5) message.data = { "Name": pipeline_info['name'], "Url title": pipeline_info['url_title'], "Add Time": pipeline_info['add_time'], "Order": pipeline_info['order_nr'] } message.attach(attachment) return message.to_json()
def add_deal(self, args): """ Adds a new deal. """ url = settings.PIPEDRIVE_ADD_DEAL + self.pipedrive_api_token body = { "title": args['title'], "value": args['value'], "currency": args['currency'], "person_id": args['Contact-person-name'], "org_id": args['Organization-Name'], "status": "", } response = requests.post(url, headers=self.headers, data=json.dumps(body)) # print(response) message = MessageClass() if response.status_code == 400: attachment = MessageAttachmentsClass() attachment.text = "No stages found in the default pipeline. Cannot add a deal." message.attach(attachment) return message.to_json() else: response_json = response.json() dealinfo = response_json['data'] message.message_text = "Deal created" attachment = MessageAttachmentsClass() field1 = AttachmentFieldsClass() field1.title = "Title" field1.value = dealinfo['title'] attachment.attach_field(field1) field2 = AttachmentFieldsClass() field2.title = "Value" field2.value = str(dealinfo['currency']) + " " + str( dealinfo['value']) attachment.attach_field(field2) field3 = AttachmentFieldsClass() field3.title = "Name" field3.value = dealinfo['person_id']['name'] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Company" field4.value = dealinfo['org_id']['name'] attachment.attach_field(field4) field5 = AttachmentFieldsClass() field5.title = "Handled by" field5.value = dealinfo['user_id']['name'] attachment.attach_field(field5) message.data = { "Title": dealinfo['title'], "Value": dealinfo['value'], "Currency": dealinfo['currency'], "Name": dealinfo['person_id']['name'], "Company": dealinfo['org_id']['name'], "Handled by": dealinfo['user_id']['name'] } message.attach(attachment) return message.to_json()
def get_my_messages(self, args): """Returns the messages of the inbox folder""" print("In get_my_messages") get_messages_url = graph_endpoint.format( '/me/mailfolders/inbox/messages') # Use OData query parameters to control the results # - Only first 10 results returned # - Only return the ReceivedDateTime, Subject, and From fields # - Sort the results by the ReceivedDateTime field in descending order query_parameters = { '$top': '10', '$select': 'receivedDateTime,subject,from', '$orderby': 'receivedDateTime DESC' } r = make_api_call('GET', get_messages_url, self.access_token, parameters=query_parameters) if r.status_code == requests.codes.ok: r_json = r.json() obj1 = r_json["value"] print(r_json) message = MessageClass() for i in range(0, len(obj1)): obj = obj1[i] id = obj["id"] bodyPreview = self.list_messages(args, id=id) attachment = MessageAttachmentsClass() attachment.title = "Subject" attachment.text = str(obj["subject"]) field1 = AttachmentFieldsClass() field1.title = "Received Date Time" field1.value = str(obj["receivedDateTime"]) attachment.attach_field(field1) if bodyPreview != None: field2 = AttachmentFieldsClass() field2.title = "Body Preview" field2.value = str(bodyPreview) attachment.attach_field(field2) from_obj = obj["from"] for j in range(0, len(from_obj)): emailAddress = from_obj["emailAddress"] field3 = AttachmentFieldsClass() field3.title = "From" field3.value = emailAddress["name"] attachment.attach_field(field3) field4 = AttachmentFieldsClass() field4.title = "Email Id" field4.value = emailAddress["address"] attachment.attach_field(field4) button1 = MessageButtonsClass() button1.text = "Forward" button1.value = "forward" button1.name = "forward" button1.command = { "service_application": self.user_integration.yellowant_integration_id, "function_name": "forward_message", "data": { "Message-Id": str(obj["id"]) }, "inputs": ["toRecipients", "Message"] } attachment.attach_button(button1) button2 = MessageButtonsClass() button2.text = "Reply" button2.value = "Reply" button2.name = "Reply" button2.command = { "service_application": self.user_integration.yellowant_integration_id, "function_name": "reply", "data": { "Message-Id": str(obj["id"]) }, "inputs": ["Message"] } attachment.attach_button(button2) message.attach(attachment) message.message_text = "Inbox messages are" return message.to_json() else: print(r.text) return "{0}: {1}".format(r.status_code, r.text)