def request_status():
object = json.loads(str(request.data).replace("b", "", 1).replace("'", ""))
print(object)
if object["status"] == "approve":
del object["status"]
access_collection = mc.return_collection("users_access_data")
parameter_to_find = {"file": object["file"], "owner": object["owner"]}
find_result = mc.find_one(parameter_to_find, access_collection)
del find_result["_id"]
replacing_result = s3.create_replace_record(find_result, object)
result = mc.replace(parameter_to_find, replacing_result, access_collection)
print(result.modified_count)
if result.modified_count == 1:
collection = mc.return_collection("user_access_request")
replace_result = s3.status_change(collection, object, "approved")
if replace_result.modified_count == 1:
return jsonify({"status": True})
else:
return jsonify({"status": False})
else:
collection = mc.return_collection("user_access_request")
replace_result = s3.status_change(collection, object, "rejected")
if replace_result.modified_count == 1:
return jsonify({"status": True})
else:
return jsonify({"status": False})
def accessed_records():
username = request.args.get('username')
access_collection = mc.return_collection("users_access_data")
filter = {"owner": username}
result = s3.file_accesses_others(mc.find(filter, access_collection))
print(result)
return jsonify(result)
def requested_access():
username = request.args.get('username')
role = request.args.get('role')
collection = mc.return_collection("user_access_request")
filter = {role: username}
# print(filter)
return jsonify(mc.find(filter, collection))
def delete_record():
object = json.loads(str(request.data).replace("b", "", 1).replace("'", ""))
collection = mc.return_collection("user_access_request")
result = mc.delete_one(object, collection)
if result.deleted_count == 1:
return jsonify({"status": True})
else:
return jsonify({"status": False})
def delete_objects():
objects = json.loads(str(request.data).replace("b", "", 1).replace("'", ""))
data = objects["Objects"]
username = objects["owner"]
del objects["owner"]
folder_access = []
backups = []
for file in data:
folder_access_temp = {}
folder_access_temp["owner"] = username
folder_access_temp["file"] = file["Key"]
backup = mc.find_one(folder_access_temp, mc.return_collection("users_access_data"))
del backup["_id"]
backups.append(backup)
folder_access.append(folder_access_temp)
print("backup", backups)
mc.delete_many(folder_access, mc.return_collection("users_access_data"))
results = []
results.append(s3.delete_objects(objects))
print(results)
def worker():
access_collection = mc.return_collection("users_access_data")
access_collection.insert_many(backups)
if (False in results):
print("inside rollback")
try:
delete_roll_back_thread = threading.Thread(target=worker())
thread = threading.Thread(target=s3.roll_back, args=(objects["Objects"],))
thread.daemon = True
delete_roll_back_thread.daemon = True
delete_roll_back_thread.start()
thread.start()
except:
print("Error: unable to Rollback")
return jsonify({"status": False})
else:
return jsonify({"status": True})
def access_request():
path = request.args.get('path')
username = request.args.get('username')
access = request.args.get('access')
owner = request.args.get('owner')
collection = mc.return_collection("user_access_request")
parameter = {"file": path, "owner": owner, "username": username, "access": access, "status": "ongoing"}
print("parameter", parameter)
result = mc.insert(parameter, collection)
print("result", result.inserted_id)
if (result.inserted_id):
return jsonify({"status": True})
else:
return jsonify({"status": False})
def branch_assignment(original_name, name):
temp = {}
temp["name"] = name
temp["trueName"] = original_name
temp["children"] = []
collection = mc.return_collection("users_access_data")
parameter = {"file": temp["trueName"]}
metadata = mc.find_one(parameter, collection)
if (metadata):
temp["owner"] = metadata["owner"]
for user in metadata["accessing_users"]:
if (user["name"] == username):
if "read" in user: temp["read"] = user["read"]
if "write" in user: temp["write"] = user["write"]
if "delete" in user: temp["delete"] = user["delete"]
return temp
def leaf_assignemnt(object):
temp = object["objectName"].split("/")
del temp[-1]
root_folder_name = "/".join(temp) + "/"
temp = {}
temp["name"] = object["objectName"].replace(root_folder_name,
"").strip()
temp["trueName"] = object["objectName"]
temp["value"] = round(object["size"] / 1024, 2)
collection = mc.return_collection("users_access_data")
parameter = {"file": object["objectName"]}
metadata = mc.find_one(parameter, collection)
if (metadata):
temp["owner"] = metadata["owner"]
for user in metadata["accessing_users"]:
if (user["name"] == username):
if "read" in user: temp["read"] = user["read"]
if "write" in user: temp["write"] = user["write"]
if "delete" in user: temp["delete"] = user["delete"]
return temp
def worker():
access_collection = mc.return_collection("users_access_data")
access_collection.insert_many(backups)
def upload_object():
print(request.data)
data = json.loads(str(request.data).replace("b", "", 1).replace("'", ""))
ownername = data["owner"]
access_collection = mc.return_collection("users_access_data")
files = data["data"]
results = []
folder_access = []
def worker():
print("worker started")
access_collection.delete_many(folder_access)
file_extension = re.compile("([a-zA-Z0-9\s_\\.\-\(\):])+(\..*)$")
if files[0]["name"] == "":
path = s3.one_folder_up(files[0]["path"])
else:
path = files[0]["path"]
objects = rc.get_keys(pattern="backup:" + path + "*")
files_from_backup = []
for object in objects:
object = str(object).replace("b", "", 1).replace("'", "").strip()
backup_file = {}
if file_extension.search(object):
backup_file["path"] = s3.one_folder_up(object.replace("backup:", "").strip())
backup_file["name"] = list(filter(None, object.split("/")))[-1]
backup_file["file"] = rc.get_object(object)
else:
backup_file["path"] = object.replace("backup:", "").strip()
backup_file["name"] = ""
backup_file["file"] = ""
files_from_backup.append(backup_file)
for each_backup_file in files_from_backup:
s3.upload_object(each_backup_file)
for file in files:
folder_access_temp = {}
folder_access_temp["owner"] = ownername
folder_access_temp["file"] = file["path"] + file["name"]
users_accessing_object = []
user_accessing_object = {}
user_accessing_object["name"] = ownername
user_accessing_object["read"] = True
user_accessing_object["write"] = True
user_accessing_object["delete"] = True
users_accessing_object.append(user_accessing_object)
folder_access_temp["accessing_users"] = users_accessing_object
folder_access.append(folder_access_temp)
version_id = s3.upload_object(file)
if (version_id):
results.append(True)
print(results)
print(folder_access)
access_collection.insert_many(folder_access)
if (False in results):
print("inside rollback")
try:
thread = threading.Thread(target=worker)
thread.daemon = True
thread.start()
except:
print("Error: unable to Rollback")
return jsonify({"status": False})
else:
return jsonify({"status": True})
