def getAccessRequestsCreatedByTheUser(self, userName):
logging.info("Inside getAccessRequestsCreatedByTheUser")
accessRequestsOfTheUserList = ModelFactory.ModelFactory().getAccessRequestsOfTheUser(
userName)
return self.accessRequestsListFormatter(accessRequestsOfTheUserList)
def fetchUserAcessDataForFilesandFoldersInDictionaryFormat(self):
logging.info("Inside fetchUserAcessDataForFilesandFoldersInDictionaryFormat")
listOfFileObjects = ModelFactory.ModelFactory().listAllFileAccessDetails()
listOfFileObjectsInDictionaryFormat = self.fileObjectsFormatToDictionaries(listOfFileObjects)
return listOfFileObjectsInDictionaryFormat
def getListOfUsersAccessingOwnersFiles(self):
logging.info("Inside getListOfUsersAccessingOwnersFiles")
ownerName = self.request["param"].get('username')
return PostgresReadTaskHandler.PostgresReadTaskHandler().getFilesInformationForSpecificUser(
ownerName)
def getAccessRequestsCreatedByUser(self):
logging.info("Inside getAccessRequestsCreatedByUser")
username = self.request["param"].get('username')
return PostgresReadTaskHandler.PostgresReadTaskHandler().getAccessRequestsCreatedByTheUser(
username)
def getAccessRequestsToBeApprovedByOwnerOfTheFile(self):
logging.info("Inside getAccessRequestsToBeApprovedByOwnerOfTheFile")
ownerName = self.request["param"].get('owner')
return PostgresReadTaskHandler.PostgresReadTaskHandler().getAccessRequestsForOwnerToApproval(
ownerName)
def getAccessRequestsForOwnerToApproval(self, ownerName):
logging.info("Inside getAccessRequestsForOwnerToApproval")
accessRequestsOfTheOwnerList = ModelFactory.ModelFactory().getAccessRequestsOfTheOwner(
ownerName)
return self.accessRequestsListFormatter(accessRequestsOfTheOwnerList)
def fetchUserAcessDataForSingleFileOrFolderInDictionaryFormat(self, fileName):
logging.info("Inside fetchUserAcessDataForSingleFileOrFolderInDictionaryFormat")
fileObject = ModelFactory.ModelFactory().getAccessDetailOfFile(fileName)
fileObjectInDictionaryFormat = self.fileObjectFormatToDictionary(fileObject)
return fileObjectInDictionaryFormat
def accessDetailsForParticularFileUserFormatter(self, AccessDetailsForFile, fileUserRecord):
logging.info("Inside accessDetailsForParticularFileUserFormatter")
AccessDetailsForFile = AccessDetailsForFile.__dict__
fileUserRecord["access"] = ""
if AccessDetailsForFile["read"] == True: fileUserRecord["access"] = fileUserRecord["access"] + "read "
if AccessDetailsForFile["write"] == True: fileUserRecord["access"] = fileUserRecord["access"] + "write "
if AccessDetailsForFile["delete"] == True: fileUserRecord["access"] = fileUserRecord["access"] + "delete"
def accessRequestsListFormatter(self, accessRequestsList):
logging.info("Inside accessRequestsListFormatter")
accessRequestsOfTheUserOrOwnerFormattedList = []
for eachAccessRequestObject in accessRequestsList:
eachAccessRequestObject = eachAccessRequestObject.__dict__
del eachAccessRequestObject["id"]
del eachAccessRequestObject["_sa_instance_state"]
accessRequestsOfTheUserOrOwnerFormattedList.append(eachAccessRequestObject)
return accessRequestsOfTheUserOrOwnerFormattedList
def fileOwnerApproveOrRejectAccessRequest(accessRequestToBeApprovedOrRejected):
logging.info("Consumer: Inside fileOwnerApproveOrRejectAccessRequest")
if accessRequestToBeApprovedOrRejected["status"] == "approve":
del accessRequestToBeApprovedOrRejected["status"]
PostgresWriteTaskHandler.PostgresWriteTaskHandler(
).approveAccessRequest(accessRequestToBeApprovedOrRejected)
else:
del accessRequestToBeApprovedOrRejected["status"]
PostgresWriteTaskHandler.PostgresWriteTaskHandler(
).rejectAccessRequest(accessRequestToBeApprovedOrRejected)
def deleteAccessRequestRecord(self, accessRequestToBeDeleted):
logging.info("Inside deleteAccessRequestRecord")
accessRequestObjectToBeDeleted = ModelFactory.ModelFactory().getAccessRequestObjectToBeDeletedOrApprovedOrRejected(
accessRequestToBeDeleted)
try:
databaseInstance.session.delete(accessRequestObjectToBeDeleted)
databaseInstance.session.commit()
logging.info("Access Request has been successfully deleted")
except:
logging.warning("Failed to delete Access Request")
def FileOwnerApproveOrRejectAccessRequest(self):
logging.info("Inside FileOwnerApproveOrRejectAccessRequest")
data_to_placed_in_the_stream = self.request["data"]
result = self.producer.send('access_management', key=self.request["task"], value=data_to_placed_in_the_stream)
sleep(5)
if (result.is_done):
logging.debug("Approve or Reject Request is initiated")
return ({"status": True})
else:
logging.warning("Approve or Reject Request is not initiated")
return ({"status": False})
def addUserToFileAccessingUserList(self, accessRequestToBeApproved):
logging.info("Inside addUserToFileAccessingUserList")
fileUserAccessObjectForGivenFileAndOwner = ModelFactory.ModelFactory().getFileAndItsAccessingUsersObjectForExistingFile(
accessRequestToBeApproved)
try:
databaseInstance.session.add(fileUserAccessObjectForGivenFileAndOwner)
databaseInstance.session.commit()
logging.info("Access Request has been successfully added to the existing file")
except:
logging.warning("Access Request has not been successfully added to the existing file")
def createAccessRequest(self, accessRequest):
logging.info("Inside createAccessRequest")
accessRequestObject = ModelFactory.ModelFactory().getAccessRequestObject()
requestMappedAccessRequestObject = RequestToDatabaseObjectMapper.RequestToDatabaseObjectMapper().RequestMappedAccessRequestObject(
accessRequestObject, accessRequest)
try:
databaseInstance.session.add(requestMappedAccessRequestObject)
databaseInstance.session.commit()
logging.info("Access Request has been successfully created")
except:
logging.warning("Failed to create Access Request")
def rejectAccessRequest(self, accessRequestToBeRejected):
logging.info("Inside rejectAccessRequest")
accessRequestForWhichStatusHasToBeRejected = ModelFactory.ModelFactory().getAccessRequestObjectToBeDeletedOrApprovedOrRejected(
accessRequestToBeRejected)
if accessRequestForWhichStatusHasToBeRejected is not None and accessRequestForWhichStatusHasToBeRejected.statusOfRequest == "ongoing":
accessRequestForWhichStatusHasToBeRejected.statusOfRequest = "rejected"
try:
databaseInstance.session.add(accessRequestForWhichStatusHasToBeRejected)
databaseInstance.session.commit()
logging.info("Access Request has been successfully rejected")
except:
logging.warning("Failed to reject Access Request")
def fileObjectFormatToDictionary(self, fileObject):
logging.info("Inside fileObjectFormatToDictionary")
fileDict = {}
fileDict["file"] = fileObject.name
fileDict["owner"] = self.getOwnerDetailsForFile(fileObject.ownerId)
fileDict["accessingUsers"] = []
for eachUser in fileObject.users:
user = {}
user["name"] = eachUser.user.name
user["read"] = eachUser.accessGiven.__dict__["read"]
user["write"] = eachUser.accessGiven.__dict__["write"]
user["delete"] = eachUser.accessGiven.__dict__["delete"]
fileDict["accessingUsers"].append(user)
return fileDict
def getFilesInformationForSpecificUser(self, ownerName):
logging.info("Inside getFilesInformationForSpecificUser")
fileObjects = ModelFactory.ModelFactory().getFilesObjectForspecificUser(
ownerName)
filesOfTheUserAccessesByOthers = []
for eachFileObject in fileObjects:
fileUserRecord = {}
fileUserRecord["file"] = eachFileObject.name
for eachUser in eachFileObject.users:
if (eachUser.user.name != ownerName):
fileUserRecord["name"] = eachUser.user.name
self.accessDetailsForParticularFileUserFormatter(eachUser.accessGiven, fileUserRecord)
filesOfTheUserAccessesByOthers.append(fileUserRecord)
return filesOfTheUserAccessesByOthers
def fileObjectsFormatToDictionaries(self, listOfFileObjects):
logging.info("Inside fileObjectsFormatToDictionaries")
listOfFileObjectsInDictionaryFormat = []
for eachFileObject in listOfFileObjects:
eachFileDict = {}
eachFileDict["file"] = eachFileObject.name
eachFileDict["owner"] = self.getOwnerDetailsForFile(eachFileObject.ownerId)
eachFileDict["accessingUsers"] = []
for eachUser in eachFileObject.users:
user = {}
user["name"] = eachUser.user.name
user["read"] = eachUser.accessGiven.__dict__["read"]
user["write"] = eachUser.accessGiven.__dict__["write"]
user["delete"] = eachUser.accessGiven.__dict__["delete"]
eachFileDict["accessingUsers"].append(user)
listOfFileObjectsInDictionaryFormat.append(eachFileDict)
return listOfFileObjectsInDictionaryFormat
def createUserAccessDetailForFile(self, accessDetailsToBeInserted):
logging.info("Inside createUserAccessDetailForFile")
numberOfAccessingUsers = len(accessDetailsToBeInserted["accessing_users"])
newFileObject = ModelFactory.ModelFactory().getFileAndItsAccessingUsersObjectForNonExistingFile(
numberOfAccessingUsers)
mappedNewFileObject = RequestToDatabaseObjectMapper.RequestToDatabaseObjectMapper().userAccessDetailToCorrespondingObect(
newFileObject, accessDetailsToBeInserted)
try:
databaseInstance.session.add(mappedNewFileObject)
databaseInstance.session.commit()
logging.info("Access Details for files have been created")
return ({"status": True})
except:
logging.warning("Error in creating Access Details for files")
return ({"status": False})
def deleteAccessDetailForFiles(self, FilesForCorrespondingAccessRecordsToBeDeleted):
logging.info("Inside deleteAccessDetailForFiles")
resultOfDeleteOperation = []
for eachFile in FilesForCorrespondingAccessRecordsToBeDeleted:
fileObject = ModelFactory.ModelFactory().getAccessDetailOfFile(eachFile["Key"])
try:
databaseInstance.session.delete(fileObject)
databaseInstance.session.commit()
resultOfDeleteOperation.append(True)
except:
resultOfDeleteOperation.append(False)
if False not in resultOfDeleteOperation:
logging.info("Access Details for files have been deleted")
return ({"status": True})
else:
logging.warning("Error in deleting Access Details for files")
return ({"status": False})
def deleteAccessRequestRecord(accessRequest):
logging.info("Consumer: Inside deleteAccessRequestRecord")
PostgresWriteTaskHandler.PostgresWriteTaskHandler(
).deleteAccessRequestRecord(accessRequest)
def createAccessRequest(accessRequest):
logging.info("Consumer: Inside createAccessRequest")
PostgresWriteTaskHandler.PostgresWriteTaskHandler().createAccessRequest(
accessRequest)
def addUserAccessDetailForFile(self):
logging.info("Inside addUserAccessDetailForFile")
accessRecordToBeInserted = self.request["data"]
return PostgresWriteTaskHandler.PostgresWriteTaskHandler(
).createUserAccessDetailForFile(accessRecordToBeInserted)
def removeUserAccessDetailsForDeletedFiles(self):
logging.info("Inside removeUserAccessDetailsForDeletedFiles")
accessRecordsToBeDeleted = self.request["data"]
return PostgresWriteTaskHandler.PostgresWriteTaskHandler(
).deleteAccessDetailForFiles(accessRecordsToBeDeleted["files"])
def fetchUserAcessDataForSingleFileOrFolder(self):
logging.info("Inside fetchUserAcessDataForSingleFileOrFolder")
fileName = self.request["param"].get('file')
return PostgresReadTaskHandler.PostgresReadTaskHandler(
).fetchUserAcessDataForSingleFileOrFolderInDictionaryFormat(fileName)
def fetchUserAcessDataForFilesAndFolders(self):
logging.info("Inside fetchUserAcessDataForFilesAndFolders")
return PostgresReadTaskHandler.PostgresReadTaskHandler(
).fetchUserAcessDataForFilesandFoldersInDictionaryFormat()
def getOwnerDetailsForFile(self, ownerId):
logging.info("Inside getOwnerDetailsForFile")
return ModelFactory.ModelFactory().getOwnerDetails(ownerId).__dict__["name"]
def catch_all(path):
transformed_request = request_preparation(request, path)
logging.info("Transformed Request From Web %s", transformed_request)
service = ServiceInterface.ServiceInterface(transformed_request)
logging.info("Response %s", service.result)
return jsonify(service.result)
