def main():
config = read_config()
config.telegram_path = ''.join(
secrets.choice(string.ascii_lowercase + string.ascii_uppercase +
string.digits) for _ in range(50))
data_base = postgresql.PostgreSQL(config.db_name, config.db_user,
config.password)
tg_bot = telegram.Telegram(config.ssl_cert, config.token,
config.telegram_path, config.host, config.port)
send_alarm_clocks = send_alarm_clock.SendAlarmClock(tg_bot, data_base)
send_alarm_clocks.start()
trash_from_db_cleaner = trash_cleaner.TrashCleaner(data_base)
trash_from_db_cleaner.start()
flask_app.FlaskApp(config.telegram_path, config.host, config.port,
config.ssl_cert, config.ssl_key, config.secret_key,
data_base, tg_bot)
print("\nShutdown started. It may take a minute")
send_alarm_clocks.work = False
trash_from_db_cleaner.close()
send_alarm_clocks.join()
send_alarm_clocks.cursor.close()
data_base.close()
tg_bot.close()
print("Done")
def handler(event, context):
logger.info(event)
if 'body' not in event:
logger.error( 'Missing parameters')
return {"isBase64Encoded": False, "statusCode": 400, "body": "Missing Body Parameter", "headers": {"Content-Type": "application/json"}}
data = json.loads(event['body']) # use for postman tests
# data = event['body'] # use for console tests
logger.info(data)
psql = postgresql.PostgreSQL()
with psql.conn.cursor() as cur:
try:
if data['operation'] == 'GET':
response = psql.queryTable('spellchecker')
resp_dict = {'result': True}
logger.info(response)
resp_list = parseResponse(response)
resp_dict['data'] = resp_list
return resp_dict
elif data['operation'] == 'ADD':
response = addWord(cur, data['values'])
resp_list = parseResponse(response)
elif data['operation'] == 'DELETE':
deleteWord(cur, data['id'])
psql.commit()
if data['operation'] == 'ADD' or data['operation'] == 'UPDATE':
return {'result': True, 'data': resp_list}
except Exception as error:
logger.error(error)
logger.error("Exception Type: %s" % type(error))
return {"isBase64Encoded": False, "statusCode": 400, "body": f'{type(error)}', "headers": {"Content-Type": "application/json"}}
return {'result': True}
def handler(event, context):
logger.info(event)
if 'body' not in event:
logger.error('Missing parameters')
return {
"isBase64Encoded": False,
"statusCode": 400,
"body": "Missing Body Parameter",
"headers": {
"Content-Type": "application/json"
}
}
data = json.loads(event['body']) # use for postman tests
# data = event['body'] # use for console tests
logger.info(data)
psql = postgresql.PostgreSQL()
with psql.conn.cursor() as cur:
try:
if data['operation'] == 'GET':
if 'id' in data.keys():
response = queryRulesID(cur, data['id'])
else:
response = queryRules(cur, data['count'])
resp_dict = {'result': True, 'data': []}
logger.info(response)
resp_list = parseResponse(response)
resp_dict['data'] = resp_list
return resp_dict
elif data['operation'] == 'ADD':
response = addRule(cur, data['values'])
resp_list = parseResponse(response)
elif data['operation'] == 'UPDATE':
response = updateRule(cur, data['values'])
resp_list = parseResponse(response)
elif data['operation'] == 'DEACTIVATE':
setRuleActivity(cur, data['id'], 'f')
elif data['operation'] == 'ACTIVATE':
setRuleActivity(cur, data['id'], 't')
psql.commit()
if data['operation'] == 'ADD' or data['operation'] == 'UPDATE':
logger.info("Applying weight")
applyWeight()
return {'result': True, 'data': resp_list}
except Exception as error:
logger.error(error)
logger.error("Exception Type: %s" % type(error))
return {
"isBase64Encoded": False,
"statusCode": 400,
"body": f'{type(error)}',
"headers": {
"Content-Type": "application/json"
}
}
return {'result': True}
def handler(event, context):
#get parameters from ssm
params = ssm.get_parameters(
Names=[
ssmPath
],
WithDecryption = True
)
logger.info("Finished Acquiring Params")
if params['ResponseMetadata']['HTTPStatusCode'] != 200:
logger.info('ParameterStore Error: ', str(params['ResponseMetadata']['HTTPStatusCode']))
return {"isBase64Encoded": False, "statusCode": params['ResponseMetadata']['HTTPStatusCode'], "body": "SSM Error", "headers": {"Content-Type": "application/json"}}
for p in params['Parameters']:
if p['Name'] == ssmPath:
ec2 = p['Value']
#get bucket name
bucket = event['Records'][0]['s3']['bucket']['name']
#get the file/key name
key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'], encoding='utf-8')
fileName = key.split("/")[1]
logger.info(bucket)
logger.info(key)
logger.info(destPath)
logger.info(ec2)
#fetch file from S3
response = s3.get_object(Bucket=bucket, Key=key)
logger.info(response)
#use ssm to send command to instance
logger.info("Got S3 Object")
ssm.send_command(
InstanceIds =[ec2],
Parameters={
'fileName': [
fileName,
],
's3Key': [
key,
],
'destPath': [
destPath,
],
'bucket':[
bucket,
],
},
DocumentName=sendCommandName
)
logger.info("Updated EC2 Instance")
# Update text configuration on postgresql
psql = postgresql.PostgreSQL()
with psql.conn.cursor() as cur:
try:
cur.execute(cmd)
psql.commit()
logger.info("Updated PostgreSQL Text Configuration")
except Exception as error:
logger.error(error)
return {"isBase64Encoded": False, "statusCode": 400, "body": f'{type(error)}', "headers": {"Content-Type": "application/json"}}
def handler(event, context):
logger.info(event)
v = event
psql = postgresql.PostgreSQL()
with psql.conn.cursor() as cur:
# insert into data_results one by one
try:
cur.execute(insert_cmd, (v["CIO_ID"], json.dumps(v), v["p5"]))
if "anatomy" not in v.keys():
# No anatomy found => sys_priority = P99
logger.info("No anatomy found for CIO ID: ", v["CIO_ID"])
cur.execute(update_sys_priority, ('P99', v["CIO_ID"]))
psql.conn.commit()
return {"rule_id": "N/A", "priority": "P99"}
else:
anatomy_str = searchAnatomy(v["anatomy"])
info_str = searchText(v, "anatomy", "medical_condition",
"diagnosis", "symptoms", "phrases",
"other_info")
command = (update_cmd % info_str) + anatomy_str + (
update_cmd_end % v["CIO_ID"])
cur.execute(command)
ret = cur.fetchall()
if not ret:
cur.execute(update_sys_priority, ('P98', v["CIO_ID"]))
psql.conn.commit()
return {"rule_id": "N/A", "priority": "P98"}
cur.execute(update_tags, (ret[0][5], v["CIO_ID"]))
tags = cur.fetchall()
# commit the changes
psql.conn.commit()
return {
"rule_id": ret[0][0],
"anatomy": ret[0][1],
"priority": ret[0][2],
"contrast": ret[0][3],
"p5_flag": ret[0][4],
"specialty_exams": tags[0][0]
}
except Exception as error:
logger.error(error)
logger.error("Exception Type: %s" % type(error))
return {
"isBase64Encoded": False,
"statusCode": 500,
"body": f'{type(error)}',
"headers": {
"Content-Type": "application/json"
}
}
def signup():
postgres_obj = postgresql.PostgreSQL()
signup_dictionary = {}
if ('username' in request.form):
signup_dictionary['username'] = request.form['username']
else:
return 'Missing parameter - username'
if ('email' in request.form):
signup_dictionary['email'] = request.form['email']
else:
return 'Missing parameter - email'
if ('password' in request.form):
signup_dictionary['password'] = request.form['password']
else:
return 'Missing parameter - password'
return postgres_obj.insert_user(signup_dictionary)
def handler(event, context):
psql = postgresql.PostgreSQL()
try:
with psql.conn.cursor() as cur:
# execute the command
lemex_a = getKeywords(cur, 'A')
lemex_b = getKeywords(cur, 'B')
lemex_c = getKeywords(cur, 'C')
lemex_d = getKeywords(cur, 'D')
setweight_a = create_setWeight('to_tsvector(info)', 'A', lemex_a)
setweight_b = create_setWeight('to_tsvector(info)', 'B', lemex_b)
setweight_c = create_setWeight('to_tsvector(info)', 'C', lemex_c)
setweight_d = create_setWeight('to_tsvector(info)', 'D', lemex_d)
list_weights = [setweight_a, setweight_b, setweight_c, setweight_d]
updateWeights(cur, 'mri_rules', 'info_weighted_tk', list_weights)
# commit the changes
psql.commit()
logger.info("Weights Finished Updating")
return {'result': True}
except Exception as error:
logger.error(error)
logger.error("Exception Type: %s" % type(error))
return {'result': False, 'msg': f'{error}'}
def login():
if (request.method != 'POST'):
return 'Request is not allowed, use POST'
else:
postgres_obj = postgresql.PostgreSQL()
login_dictionary = {}
# if('password' in request.form):
# login_dictionary['password'] = request.form['password']
# else:
# return 'Missing parameter - password'
#
# if('username' in request.form):
# login_dictionary['username'] = request.form['username']
# elif('email' in request.form):
# login_dictionary['email'] = request.form['email']
# else:
# return 'Missing parameter - email/username'
# return jsonify(
# msg=json.dumps(login_dictionary)
# )
return postgres_obj.authenticate(login_dictionary)
def handler(event, context):
logger.info(event)
if 'body' not in event:
logger.error( 'Missing parameters')
return {"isBase64Encoded": False, "statusCode": 400, "body": "Missing Body Parameter", "headers": {"Content-Type": "application/json"}}
data = json.loads(event['body']) # use for postman tests
# data = event['body'] # use for console tests
logger.info(data)
psql = postgresql.PostgreSQL()
with psql.conn.cursor() as cur:
try:
resp_dict = {'result': True, 'data': []}
if data['operation'] == 'GET':
if 'id' in data.keys():
response = parseResponse(queryResultsID(cur, data['id']))
else:
response = parseResponse(queryResults(cur, data['page']))
resp_dict['total_pgs']= queryPageCount(cur)
elif data['operation'] == 'UPDATE':
response = updateResults(cur, data['id'], data['phys_priority'], data['phys_contrast'])
response = [{'id': response[0][0], 'phys_priority': response[0][1], 'phys_contrast': response[0][2]}]
elif data['operation'] == 'GET_DATA':
daily = getResultCount(cur, 'DAILY')
weekly = getResultCount(cur, 'WEEKLY')
monthly = getResultCount(cur, 'MONTHLY')
response = [{'daily': daily, 'weekly': weekly, 'monthly': monthly}]
psql.commit()
logger.info(response)
resp_dict['data'] = response
return resp_dict
except Exception as error:
logger.error(error)
logger.error("Exception Type: %s" % type(error))
return {"isBase64Encoded": False, "statusCode": 400, "body": f'{type(error)}', "headers": {"Content-Type": "application/json"}}
return {'result': True}
from datetime import datetime, date
from spellchecker import SpellChecker
import psycopg2
from psycopg2 import sql
import postgresql
logger = logging.getLogger()
logger.setLevel(logging.INFO)
compr = boto3.client(service_name='comprehend')
compr_m = boto3.client(service_name='comprehendmedical')
lambda_client = boto3.client('lambda')
RuleProcessingLambdaName = os.getenv('RULE_PROCESSING_LAMBDA')
spell = SpellChecker()
psql = postgresql.PostgreSQL()
conj_list = psql.queryTable("conjunctions")
spelling_list = [x[0] for x in psql.queryTable('spellchecker')]
psql.closeConn()
# Add words to spell list
spell.word_frequency.load_words(spelling_list)
def convert2CM(height):
if not isinstance(height, str):
return 0
try:
parts = height.split(' ')
unit = parts[1]
if unit == 'CM':
return float(parts[0])
