def main(msg: func.ServiceBusMessage):
message = msg.get_body().decode('utf-8')
body = json.loads(message)
action = body['Message']
params = body['MessageAttributes']
worker = WORKER_NAME_MAP[action]
worker_type = worker['type']
worker_name = worker['name']
input = {k: params[k]['Value'] for k in params.keys()}
job_id = input['job_id']
tenant_id = input['tenant_id']
result = json.dumps({
'message_id': msg.message_id,
'body': msg.get_body().decode('utf-8'),
'worker_type': worker_type,
'worker_name': worker_name,
'job_id': job_id,
'tenant_id': tenant_id,
'content_type': msg.content_type,
'expiration_time': msg.expiration_time,
'label': msg.label,
'partition_key': msg.partition_key,
'reply_to': msg.reply_to,
'reply_to_session_id': msg.reply_to_session_id,
'scheduled_enqueue_time': msg.scheduled_enqueue_time,
'session_id': msg.session_id,
'time_to_live': msg.time_to_live,
'to': msg.to,
'user_properties': msg.user_properties,
})
logging.info(result)
def main(message: func.ServiceBusMessage):
notification_id = None
try:
notification_id = int(message.get_body().decode('utf-8'))
logging.info(
'Python ServiceBus queue trigger processed message: %s', notification_id)
except Exception as e:
logging.error('Invalid entry, skipping message {}'.format(message.get_body().decode('utf-8')))
return
conn = None
cur = None
nRepo = NoticationRepo()
try:
conn = get_conn(SSL_PATH)
logging.info("Connection successful")
cur = conn.cursor()
n = nRepo.getById(notification_id, cur)
if n != None:
ats = AttendeeRepo().getAttendees(cur)
for at in ats:
subject = '{}: {}'.format(at.firstName, n.subject)
send_email(at.email, n.subject, n.message)
n.setNotificationCompleted(len(ats))
nRepo.setCompleted(n, cur, conn)
except Exception as e:
logging.error('General Exception: ' + str(e))
finally:
closeDb(cur, conn)
async def main(msg: func.ServiceBusMessage):
try:
logging.info('Python ServiceBus queue trigger processed message: %s',
msg.get_body().decode('utf-8'))
raise Exception('something went wrong')
except Exception:
retry_count = int(msg.user_properties['retry-count']
) if 'retry-count' in msg.user_properties else 0
# If there are retries remaining
if retry_count < RETRY_LIMIT:
# Calculate a delay of seconds for next message
retry_count += 1
delay_seconds = retry_count * RETRY_MULTIPLIER_SECONDS
logging.info('Scheduling message for the %i retry in %i seconds',
retry_count, delay_seconds)
# Schedule and resend message onto queue
async with queue_client.get_sender() as sender:
message = Message(msg.get_body())
message.message_id = msg.message_id
message.user_properties = {
'original-message-id': msg.message_id,
'retry-count': retry_count
}
enqueue_time = datetime.now() + timedelta(
seconds=delay_seconds)
await sender.schedule(enqueue_time, message)
else:
logging.error('Exhausted all retries')
def main(msg: func.ServiceBusMessage):
logging.info('Python ServiceBus queue trigger processed message: %s')
logging.info(msg.get_body().decode('utf-8'))
logging.info('sleeping....')
time.sleep(900)
logging.info('completing')
logging.info(msg.get_body().decode('utf-8'))
async def main(msg: func.ServiceBusMessage, starter: str):
logging.info("starting analyze_text_handler")
message_body = msg.get_body().decode('utf-8')
logging.info(f"message body: {message_body}")
message_details = json.dumps({
'message_id': msg.message_id,
'body': msg.get_body().decode('utf-8'),
'content_type': msg.content_type,
# 'expiration_time': msg.expiration_time,
'label': msg.label,
'partition_key': msg.partition_key,
'reply_to': msg.reply_to,
'reply_to_session_id': msg.reply_to_session_id,
# 'scheduled_enqueue_time': msg.scheduled_enqueue_time,
'session_id': msg.session_id,
'time_to_live': msg.time_to_live,
'to': msg.to,
'user_properties': msg.user_properties,
'metadata' : msg.metadata
})
logging.info(message_details)
# State the orchestration function
logging.info("starting analyze_text_orchestration")
client = df.DurableOrchestrationClient(starter)
instance_id = await client.start_new("analyze_text_orchestration", client_input=message_body)
logging.info(f"started orchestration with instance id: {instance_id}")
# How to manage an orchestration instance
# https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-instance-management?tabs=python
def main(msg: func.ServiceBusMessage):
logging.info('Python ServiceBus queue trigger processed message: %s',
msg.get_body().decode('utf-8'))
message = msg.get_body().decode('utf-8')
print("message = {}".format(message))
message_json = json.loads(message)
first_name = message_json.get('firstName')
print("firstName = {}".format(first_name))
def main(message: func.ServiceBusMessage) -> func.InputStream: #pylint: disable=E1136
# Log the Service Bus Message as plaintext
#message_content_type = message.content_type
message_body = message.get_body().decode("utf-8")
logging.info("Python ServiceBus topic trigger processed message.")
#logging.info("Message Content Type: " + message_content_type)
logging.info("Message Body: " + message_body)
messagePayload = json.loads(message_body)
receiptUrl = messagePayload["receiptUrl"]
r = requests.get(receiptUrl)
pdfEncoded = b64encode(r.content)
outPayload = {
"Store": messagePayload["storeLocation"],
"SalesNumber": messagePayload["salesNumber"],
"TotalCost": messagePayload["totalCost"],
"Items": messagePayload["totalItems"],
"SalesDate": messagePayload["salesDate"],
"ReceiptImage": pdfEncoded.decode('utf-8')
}
return json.dumps(outPayload)
def main(msg: func.ServiceBusMessage):
result = msg.get_body().decode('utf-8')
results = json.loads(result)
item_payload = {
'id': str(uuid.uuid1()),
'timestamp': results['created'],
'prediction': results['predictions']['tagName'],
'probability': results['predictions']['probability'],
'resolved': False
}
# {
# "id": "",
# "predictions": {
# "probability": 0.2551375,
# "boundingBox": {
# "left": 0.00870211,
# "height": 0.82958604,
# "top": 0.01420201,
# "width": 0.53497158
# },
# "tagId": 5,
# "tagName": "glass container"
# },
# "created": "2019-08-31T12:25:58.163379",
# "project": "",
# "iteration": ""
# }
# Only post if higher then 50%
if results['predictions']['probability'] > 0.5:
# Create and add some items to the container
item = client.CreateItem(container['_self'], item_payload)
def main(message: func.ServiceBusMessage):
message_content_type = message.content_type
message_body = message.get_body().decode("utf-8")
logging_info = {
"Message Content Type": message_content_type,
"Message Body": message_body
}
logging.info(json.dumps(logging_info))
storage_receipt_conn_str = os.environ.get('storage_receipt_conn_str')
storage_receipt_lt100_container = os.environ.get(
'storage_receipt_lt100_container')
receipt_json = json.loads(message_body)
receipt_lt100_json = {
"Store": receipt_json["storeLocation"],
"SalesNumber": receipt_json["salesNumber"],
"TotalCost": receipt_json["totalCost"],
"Items": receipt_json["totalItems"],
"SalesDate": receipt_json["salesDate"]
}
blob_name = receipt_json["salesNumber"] + '.json'
blob_service = blob.BlobClient.from_connection_string(
storage_receipt_conn_str, storage_receipt_lt100_container, blob_name)
blob_service.upload_blob(json.dumps(receipt_lt100_json), overwrite=True)
async def run(msg: func.ServiceBusMessage):
try:
global nlp
if nlp is None:
nlp = get_model()
if msg.message_id == "warmup-message":
return
paragraph_text = msg.get_body().decode('utf-8')
topics_connection_string = os.environ["WordTopicsConnection"]
q_connection_string = os.environ["TextQueuesConnection"]
if nlp is None:
nlp = get_model()
doc = nlp(paragraph_text)
paragraphs_task = asyncio.create_task(
send_paragraph(q_connection_string, doc, msg.correlation_id,
msg.user_properties))
lemmas = get_lemmas(doc)
create_rule_for_dictionary_articles(
topics_connection_string, msg.correlation_id,
msg.user_properties["ParagraphNumber"], lemmas)
lemmas_task = asyncio.create_task(
send_lemmas(topics_connection_string, lemmas, msg.correlation_id,
msg.user_properties))
await paragraphs_task
await lemmas_task
except Exception as ex:
message = str.format("Error: {}", ex)
logging.error(message)
def main(msg: azf.ServiceBusMessage) -> str:
result = json.dumps({
'message_id':
msg.message_id,
'body':
msg.get_body().decode('utf-8'),
'content_type':
msg.content_type,
'delivery_count':
msg.delivery_count,
'expiration_time':
(msg.expiration_time.isoformat() if msg.expiration_time else None),
'label':
msg.label,
'partition_key':
msg.partition_key,
'reply_to':
msg.reply_to,
'reply_to_session_id':
msg.reply_to_session_id,
'scheduled_enqueue_time': (msg.scheduled_enqueue_time.isoformat()
if msg.scheduled_enqueue_time else None),
'session_id':
msg.session_id,
'time_to_live':
msg.time_to_live,
'to':
msg.to,
'user_properties':
msg.user_properties,
})
return result
def main(msg: func.ServiceBusMessage):
"""When a message arrives on the servicebus, send a trigger to IoT Hub to start the fan for that device.
Args:
msg (func.ServiceBusMessage): Message from the connected Queue in a Azure ServiceBus
"""
# Extract the method into a dictionary
msg_dict = json.loads(msg.get_body().decode("utf-8"))
logging.info(
f"Python ServiceBus queue trigger processed message: {msg_dict}")
# Enable a connection with the IoT Hub. The connectionstring for the IoT Hub
# is preloaded in the Azure Functions configurations.
connectino_string_iothub = os.getenv("connectionStringIotHub")
registry_manager = IoTHubRegistryManager(connectino_string_iothub)
# Settings for the method that the IoT Device should run upon receiving the message.
callback_method = "start_fan"
callback_payload = {}
device_method = CloudToDeviceMethod(method_name=callback_method,
payload=callback_payload)
# Sending the actual cloud-to-device message and invoke a function on the IoT device.
device_id = msg_dict["IoTHub"]["ConnectionDeviceId"]
response = registry_manager.invoke_device_method(device_id, device_method)
print("")
print("Device Method called")
print("Device Method name : {0}".format(callback_method))
print("Device Method payload : {0}".format(callback_payload))
print("")
print("Response status : {0}".format(response.status))
print("Response payload : {0}".format(response.payload))
def main(msg: func.ServiceBusMessage):
notification_id = None
try:
notification_id = int(msg.get_body().decode('utf-8'))
logging.info('Python ServiceBus queue trigger processed message: %s',
notification_id)
except Exception as e:
logging.error('Message is not valid {}'.format(
message.get_body().decode('utf-8')))
return
try:
con = get_connection()
cur = con.cursor()
notification = get_notication(cur, notification_id)
if notification != None:
attendees = get_attendees(cur)
for attendee in attendees:
subject = '{}: {}'.format(attendee['firstName'],
notification['subject'])
send_email(attendee['email'], notification['subject'],
notification['message'])
set_notif_complete(cur, con, notification, len(attendees))
except Exception as e:
logging.error('Exception: ' + str(e))
finally:
close_connection(cur, con)
def main(msg: func.ServiceBusMessage):
sms_event_data = SmsRecieved(loads(msg.get_body().decode('utf-8')))
sms = SimpleMessagingService(
leased_phone_number=environ['LEASED_PHONE_NUMBER'],
target_phone_numbers=environ['TARGET_PHONE_NUMBERS'],
comm_service_connection_string=environ['COMM_SERVICE_CONNECTION_STRING']
)
sms.send_sms(message_to_send=f'Sent from {sms_event_data.data.message_from}: {sms_event_data.data.message}')
def main(msg: func.ServiceBusMessage):
logging.info('function Invoked')
notification_id = int(msg.get_body().decode('utf-8'))
logging.info('Python ServiceBus queue trigger processed message: %s',
notification_id)
# TODO: Get connection to database
dbname = "techconfdb"
user = "******"
password = "******"
host = "techconfdb.postgres.database.azure.com"
sslmode = "require"
conn_string = "host={0} user={1} dbname={2} password={3} sslmode={4}".format(
host, user, dbname, password, sslmode)
conn = psycopg2.connect(conn_string)
logging.info('after connetion:')
cursor = conn.cursor()
try:
# TODO: Get notification message and subject from database using the notification_id
cursor.execute("SELECT * FROM notification WHERE id = %s;",
(notification_id, ))
notification = cursor.fetchone()
# TODO: Get attendees email and name
cursor.execute("SELECT * FROM attendee;")
attendees = cursor.fetchall()
attendees_count = str(cursor.rowcount)
cursor.execute(
"UPDATE notification SET status = %s, completed_date = %s WHERE id = %s;",
("Notified {} attendees".format(attendees_count),
datetime.utcnow(), notification_id))
# TODO: Loop through each attendee and send an email with a personalized subject
for attendee in attendees:
send_email(
str(attendee[5]), "{} {} {}".format(str(notification[5]),
str(attendee[1]),
str(attendee[2])),
str(notification[2]))
# TODO: Update the notification table by setting the completed date and updating the status with the total number of attendees notified
cursor.execute(
"UPDATE notification SET status = %s, completed_date = %s WHERE id = %s;",
("Notified {} attendees".format(attendees_count),
datetime.utcnow(), notification_id))
except (Exception, psycopg2.DatabaseError) as error:
logging.error(error)
finally:
# TODO: Close connection
conn.commit()
cursor.close()
conn.close()
logging.info("Connection Closed")
def main(message: func.ServiceBusMessage):
# Log the Service Bus Message as plaintext
#message_content_type = message.content_type
message_body = message.get_body().decode("utf-8")
logging.info("Python ServiceBus topic trigger processed message.")
#logging.info("Message Content Type: " + message_content_type)
logging.info("Message Body: " + message_body)
def main(msg: func.ServiceBusMessage):
twitter_key = os.environ['TwitterAPIKey']
twitter_secret = os.environ['TwitterAPISecret']
twitter_access_token = os.environ['TwitterAccessToken']
twitter_access_token_secret = os.environ['TwitterAccessTokenSecret']
# Setup auth
twitter_auth = tweepy.OAuthHandler(twitter_key, twitter_secret)
twitter_auth.set_access_token(twitter_access_token,
twitter_access_token_secret)
# Create twitter API object
tweeter = tweepy.API(twitter_auth)
# Tweet message
body_content = msg.get_body().decode('utf-8')
tweeter.update_status(body_content)
logging.info('Python ServiceBus queue trigger processed message: %s',
msg.get_body().decode('utf-8'))
def main(msg: func.ServiceBusMessage):
notification_id = int(msg.get_body().decode('utf-8'))
logging.info('Python ServiceBus queue trigger processed message: %s',
notification_id)
connection = psycopg2.connect(
user="******",
password="******",
host="uda-postgresql.postgres.database.azure.com",
port="5432",
database="techconfdb")
cursor = connection.cursor()
try:
notification_query = '''SELECT subject, message
FROM Notification
WHERE id = %s;'''
cursor.execute(notification_query, (notification_id, ))
notification = cursor.fetchone()
subject = notification[0]
message = notification[1]
attendees_query = 'SELECT first_name, email FROM Attendee;'
cursor.execute(attendees_query)
attendees = cursor.fetchall()
for attendee in attendees:
first_name = attendee[0]
email = attendee[1]
custom_subject = '{}: {}'.format(first_name, subject)
# send_email(email, custom_subject, message)
completed_date = datetime.utcnow()
status = 'Notified {} attendees'.format(len(attendees))
notification_update_query = '''UPDATE Notification
SET completed_date = %s, status = %s
WHERE id = %s;'''
cursor.execute(notification_update_query,
(completed_date, status, notification_id))
connection.commit()
count = cursor.rowcount
print(count, "Record Updated successfully ")
except (Exception, psycopg2.DatabaseError) as error:
logging.error(error)
finally:
#closing database connection.
if (connection):
cursor.close()
connection.close()
print("PostgreSQL connection is closed")
def main(msg: func.ServiceBusMessage):
scrape_json = msg.get_body().decode('utf-8')
scrape_obj = scrape.Scrape(**json.loads(scrape_json))
proc = best_buy_processor.BestBuyProcessor()
scrpr = scraper.Scraper()
status = scrpr.scrape(scrape_obj, proc)
# Clear out any possible null values
return json.dumps({k: v for k, v in status._asdict().items() if v})
def main(message: ServiceBusMessage) -> NoReturn:
logging.info(
f"--- ServiceBus event has triggered the function. Starting the process"
)
message = loads(message.get_body().decode())
logging.info(f"Message: {message}")
repopulate(message)
return None
async def main(message: ServiceBusMessage, starter: str) -> NoReturn:
logging.info(
f"--- ServiceBus event has triggered the function. Starting the process"
)
client = DurableOrchestrationClient(starter)
raw_message = message.get_body().decode()
message = loads(raw_message)
logging.info(f"Message: {raw_message}")
instance_id = await client.start_new("despatch_ops_orchestrator",
instance_id=message.get(
"instance_id", None),
client_input=raw_message)
logging.info(
f"Started orchestration for 'despatch_ops_orchestrator' with ID = '{instance_id}'."
)
return None
def main(msg: func.ServiceBusMessage):
notification_id = int(msg.get_body().decode('utf-8'))
logging.info('Python ServiceBus queue trigger processed message: %s',
notification_id)
# TODO: Get connection to database
dbname = "techconfdb"
user = "******"
host = "techcondb.postgres.database.azure.com"
password = "******"
conn = psycopg2.connect(host=host,
dbname=dbname,
user=user,
password=password)
try:
# TODO: Get notification message and subject fron database using the notification_id
cur = conn.cursor()
notf_query = f"select message, subject form notifications where id = {notification_id}"
cur.execute(notf_query)
notification_message, subject = cur.fetchall()
# TODO: Get attendees email and name
attendees_query = "select email, name from attendee"
cur.execute(attendees_query)
# TODO: Loop thru each attendee and send an email with a personalized subject
attendees = cur.fetchall()
if not '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"':
for attendee in attendees:
message = Mail(from_email="*****@*****.**",
to_emails=attendee[0],
subject=subject,
plain_text_content=notification_message)
sg = SendGridAPIClient(
'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"'
)
sg.send(message)
# TODO: Update the notification table by setting the completed date and updating the status with the total number of attendees notified
status = f'Notified {msg.delivery_count} attendees'
query = f'update notification set status = {status}, completed_date = {datetime.utcnow()} where id = {notification_id}'
cur.execute(query)
except (Exception, psycopg2.DatabaseError) as error:
logging.error(error)
finally:
# TODO: Close connection
if (conn):
conn.commit()
cur.close()
conn.close()
print("PostgresSQL connection closed \n")
def main(msg: func.ServiceBusMessage):
# logging.info('Python ServiceBus queue trigger processed message: %s',
# msg.get_body().decode('utf-8'))
notification_id = int(msg.get_body().decode('utf-8'))
logging.info('Python ServiceBus queue trigger processed message: %s',notification_id)
# TODO: Get connection to database
conn = psycopg2.connect(
host=',
dbname='techconfdb',
user='',
password=''
)
cursor = conn.cursor()
try:
# TODO: Get notification message and subject from database using the notification_id
query = "SELECT message, subject FROM notification WHERE id = {0}".format(notification_id)
cursor.execute(query)
notification = cursor.fetchone()
# TODO: Get attendees email and name
query = "SELECT email, CONCAT(first_name, ' ', last_name) FROM attendee"
cursor.execute(query)
attendees = cursor.fetchall()
# TODO: Loop through each attendee and send an email with a personalized subject
for attendee in attendees:
# logging.info('attendee[0]: %s',attendee[0])
# logging.info('notification[0]: %s',notification[0])
# logging.info('notification[1]: %s',notification[1])
Mail(
"*****@*****.**",
attendee[0],
notification[1],
notification[0]
)
# TODO: Update the notification table by setting the completed date and updating the status with the total number of attendees notified
status = "Notified {0} attendees".format(len(attendees))
query = "UPDATE notification SET status = '{0}', completed_date='{1}' WHERE id = {2}".format(status, datetime.utcnow(), notification_id)
cursor.execute(query)
conn.commit()
except (Exception, psycopg2.DatabaseError) as error:
logging.error(error)
finally:
# TODO: Close connection
conn.close()
def main(msg: func.ServiceBusMessage):
notification_id = int(float(msg.get_body().decode('utf-8')))
logging.info('Python ServiceBus queue trigger processed message: %s',
notification_id)
# Get connection to database
conn = psycopg2.connect(
dbname="techconfdb",
user="******",
password="******",
host="sqlserver20210405.postgres.database.azure.com")
cur = conn.cursor()
try:
# Get notification message and subject from database using the notification_id
cur.execute(
"SELECT subject, message FROM notification WHERE id={};".format(
notification_id))
result = cur.fetchall()
subject, body = result[0][0], result[0][1]
# Get attendees email and name
cur.execute("SELECT email, first_name FROM attendee;")
attendees = cur.fetchall()
# Loop through each attendee and send an email with a personalized subject
for (email, first_name) in attendees:
mail = Mail(from_email='*****@*****.**',
to_emails=email,
subject=subject,
plain_text_content="Hi {}, \n {}".format(
first_name, body))
try:
SENDGRID_API_KEY = os.environ['SENDGRID_API_KEY']
sg = SendGridAPIClient(SENDGRID_API_KEY)
response = sg.send(mail)
except Exception as e:
logging.error(e)
status = "Notified {} attendees".format(len(attendees))
# Update the notification table by setting the completed date and updating the status with the total number of attendees notified
cur.execute(
"UPDATE notification SET status = '{}', completed_date = '{}' WHERE id = {};"
.format(status, datetime.utcnow(), notification_id))
# cur.execute("INSERT INTO notification(status, message, completed_date, subject) VALUES ('{}', '{}', '{}','{}');".format(status, body, datetime.utcnow(), subject))
conn.commit()
except (Exception, psycopg2.DatabaseError) as error:
logging.error(error)
conn.rollback()
finally:
# Close connection
cur.close()
conn.close()
def main(message: func.ServiceBusMessage):
# set teams variables
url = os.environ['TEAMS_URL_WEBHOOK']
account = os.environ["TENANT_NAME"]
# Log the Service Bus Message as plaintext
message_body = message.get_body().decode("utf-8")
logging.info('Python ServiceBus topic trigger processed message.')
logging.info(f'Message Body: {message_body}')
message = json.loads(message_body)
findings = message['scanning_result'].get('Findings')
if findings:
malwares = []
types = []
for finding in findings:
malwares.append(finding.get('malware'))
types.append(finding.get('type'))
malwares = ', '.join(malwares)
types = ', '.join(types)
file_url = str(message['file_url'])
payload = {
"summary":
"Malicious Object Detected",
"sections": [{
"activityTitle":
"A <b>Malicious object</b> has been detected!"
}, {
"markdown":
False,
"facts": [{
"name": "Azure Tenant:",
"value": account
}, {
"name": "Malware Name(s):",
"value": malwares
}, {
"name": "Malware Type(s):",
"value": types
}, {
"name": "File URL:",
"value": file_url
}]
}]
}
encoded_msg = json.dumps(payload).encode('utf-8')
resp = http.request('POST', url, body=encoded_msg)
logging.info(f'sending ms teams response: {resp}')
def sd_xmltojson_function(msgIn: func.ServiceBusMessage,
msgOut: func.Out[str]):
try:
strxml = msgIn.get_body().decode('utf-8')
logging.info('Received xml from sdxmlqueue: %s', strxml)
outMsgDict = xmltodict.parse(strxml,
namespaces=namespaces,
cdata_key='_value')
logging.debug('Converted xml to json message: %s', outMsgDict)
msgOut.set(json.dumps(outMsgDict))
except Exception as e:
logging.error('Failed to parse xml: {}'.format(str(e)))
raise e
def main(msg: func.ServiceBusMessage):
logging.info(
"Python Cosmos DB messaging automation function receiving message {0}".
format(msg.message_id))
try:
msg_body = msg.get_body().decode('utf-8')
msg_json = json.loads(msg_body)
resource_group_name_res_id = msg_json['resource_group_name']
account_name_res_id = msg_json['account_name']
if resource_group_name != resource_group_name_res_id:
raise ValueError(
'Invalid Alert Resource Group. Expected alert for resource group {0} and received {1}. Review the Azure Metric Alert and action group configuration.'
.format(resource_group_name, resource_group_name_res_id))
if account_name != account_name_res_id:
raise ValueError(
'Invalid Alert Cosmos Db Account. Expected alert for cosmos db account {0} and received {1}. Review the Azure Metric Alert and action group configuration.'
.format(account_name, account_name_res_id))
except ValueError as err:
logging.error(err.args)
raise
else:
alert_rule_name = msg_json['alert_rule_name']
severity = msg_json['severity']
logging.info(
'Python Cosmos DB messaging automation function processing alert {0} with severity {1}'
.format(alert_rule_name, severity))
try:
client.database_accounts.update_sql_container_throughput(
resource_group_name,
account_name,
database_name,
container_name,
resource=container_rus)
logging.info(
'Successfully provisioned {0} resources units for {1}/sql/{2}/{3}'.
format(container_rus["throughput"], account_name, database_name,
container_name))
except Exception as e:
logging.error(
'\ncosmosdb-provision-rus has caught an error. {0}'.format(e))
# since Azure Functions Service trigger are using PeekLock connection mode we expect this raise to send this message to the DLQ
raise
finally:
logging.info("\ncosmosdb-provision-rus done")
def main(msg: func.ServiceBusMessage):
notification_id = int(msg.get_body().decode('utf-8'))
logging.info('Python ServiceBus queue trigger processed message: %s',
notification_id)
# TODO: Get connection to database
# Update connection string information
host = "techconfdbudacity.postgres.database.azure.com"
dbname = "techconfdb"
user = "******"
password = "******"
sslmode = "require"
# Construct connection string
conn_string = "host={0} user={1} dbname={2} password={3} sslmode={4}".format(
host, user, dbname, password, sslmode)
conn = psycopg2.connect(conn_string)
print("Connection established")
try:
# TODO: Get notification message and subject fron database using the notification_id
cursor = conn.cursor()
cursor.execute("SELECT * FROM Notification WHERE id = %s;",
(notification_id, ))
notification = cursor.fetchall()
print(notification[0][0])
# TODO: Get attendees email and name
cursor.execute("SELECT * FROM Attendee;")
rows = cursor.fetchall()
# TODO: Loop thru each attendee and send an email with a personalized subject
for row in rows:
print("Data row = (%s, %s, %s)" %
(str(row[0]), str(row[1]), str(row[2])))
subject = '{}: {}'.format(str(row[0]), str(notification[0][3]))
# TODO: Update the notification table by setting the completed date and updating the status with the total number of attendees notified
cursor.execute(
"UPDATE Notification SET completed_date = %s WHERE id = %s;",
(datetime.utcnow(), notification_id))
cursor.execute(
"UPDATE Notification SET status = %s WHERE id = %s;",
('Notified {} attendees'.format(len(rows)), notification_id))
except (Exception, psycopg2.DatabaseError) as error:
logging.error(error)
finally:
# TODO: Close connection
conn.commit()
cursor.close()
conn.close()
def main(msg: func.ServiceBusMessage):
notification_id = int(msg.get_body().decode('utf-8'))
logging.info('Python ServiceBus queue trigger processed message: %s',
notification_id)
# Get connection to database
connection = psycopg2.connect(
host="migratedbproject.postgres.database.azure.com",
dbname="techconfdb",
user="******",
password="******")
cursor = connection.cursor()
try:
# Get notification message and subject from database using the notification_id
logging.info('Fetching notification message and subject...')
notification_query = cursor.execute(
"SELECT message, subject FROM notification WHERE id = {};".format(
notification_id))
# Get attendees email and name
logging.info('Fetching attendees email and name...')
cursor.execute("SELECT first_name, last_name, email FROM attendee;")
attendees = cursor.fetchall()
# Loop through each attendee and send an email with a personalized subject
logging.info('Sending emails...')
for attendee in attendees:
Mail('{}, {}, {}'.format({'*****@*****.**'},
{attendee[2]}, {notification_query}))
# Update the notification table by setting the completed date and updating the status with the total number of attendees notified
logging.info('Updating notifications...')
notification_completed_date = datetime.utcnow()
notification_status = 'Notified {} attendees'.format(len(attendees))
update_query = cursor.execute(
"UPDATE notification SET status = '{}', completed_date = '{}' WHERE id = {};"
.format(notification_status, notification_completed_date,
notification_id))
connection.commit()
except (Exception, psycopg2.DatabaseError) as error:
logging.error(error)
connection.rollback()
finally:
# Close connection
cursor.close()
connection.close()
def main(msg: func.ServiceBusMessage):
notification_id = int(msg.get_body().decode('utf-8'))
logging.info('Python ServiceBus queue trigger processed message: %s',notification_id)
# TODO: Get connection to database
conn = psycopg2.connect(dbname="", user="", password="", host="")
print("Connection established")
cursor = conn.cursor()
try:
# TODO: Get notification message and subject from database using the notification_id
cursor.execute("select status, message from public.notification where id = "+str(notification_id))
notification = cursor.fetchall()
# TODO: Get attendees email and name
cursor.execute("select last_name,email from public.attendee")
mail = cursor.fetchall()
# https://docs.microsoft.com/de-de/azure/postgresql/flexible-server/connect-python
# https://sendgrid.com/docs/for-developers/sending-email/v3-python-code-example/
# TODO: Loop through each attendee and send an email with a personalized subject
for m in mail:
#print(m[1])
message = Mail(
from_email='*****@*****.**',
to_emails=m[1],
subject='Updated',
html_content='Message')
completed_date = datetime.utcnow()
#print(completed_date)
notification_status = 'Notified {} people'.format(len(mail))
logging.info('Python ServiceBus queue trigger processed message: %s',len(mail))
# TODO: Update the notification table by setting the completed date and updating the status with the total number of attendees notified
cursor.execute("UPDATE public.notification SET status = '{}', completed_date = '{}' WHERE id = {};".format(notification_status, completed_date, notification_id))
#print(completed_date)
conn.commit()
except (Exception, psycopg2.DatabaseError) as error:
logging.error(error)
conn.rollback()
finally:
# TODO: Close connection
cursor.close()
conn.close()
def main(msg: func.ServiceBusMessage):
logging.info('Python ServiceBus topic trigger processed message: %s',
msg.get_body().decode('utf-8'))