def move_file(self, user, curr_seg, file_name, next_seg):
"""
handle moving files to other segs
"""
try:
print curr_seg.get_user_premission(user.get_name())
if curr_seg.__can_change__(
user.get_name()) and next_seg.__can_change__(
user.get_name()):
print 'movingggg'
db.write_in_log(
Cloud.event_log_dir, "moving file: " +
str(datetime.datetime.now()) + "--" + file_name + ':' +
curr_seg.get_name() + '->' + next_seg.get_name())
#file_id = self.segments[curr_seg.get_name()].get_file_id(file_name)
if db.move_file_to_another_seg(self.cloud_dir,
curr_seg.get_name(),
next_seg.get_name(), file_name):
next_seg.add_file(
user.get_name(),
(curr_seg.delete_file(user.get_name(), file_name)))
return True
return False
except:
print "failed"
return False
def add(self, user, file_path, file_binary):
"""
create and save the file data in the server folder and in the database
"""
premission = self.users_and_premissions[user]
print user, "pre: ", premission, "uploading: ", file_path, "file binary: ", len(
file_binary)
if premission == 'W' or premission == 'A':
#file_data = (file_path.split('\\')[-1]).split('.')
file_data = os.path.splitext(os.path.basename(file_path))
file_name, file_extention = file_data[0], file_data[1]
file_name = self.name_management(file_name)
saved_file_path = os.path.join(Cloud.files_data_dir, file_name)
if db.add_file(self.cloud_dir, file_name, file_extention,
file_binary, saved_file_path, self.name):
self.files.append(
(file_name, file_extention, len(file_binary)))
print self.name, " files: ", self.files
db.write_in_log(
Cloud.event_log_dir,
user + "file added " + str(datetime.datetime.now()) + "seg: " +
self.name + ' file data: ' + str(
(file_name, file_extention, len(file_binary))))
return True
else:
return False
def __del__(self):
"""
delete the seg
"""
db.write_in_log(
Cloud.event_log_dir, "seg deleted--" +
str(datetime.datetime.now()) + "--seg name: " + str(self.name))
return db.delete_seg(self.cloud_dir, self.name)
def __create_event_log__(self, dir_name):
"""
create the event_log file
"""
if not os.path.isfile(dir_name):
with open(dir_name, 'w') as f:
db.write_in_log(Cloud.event_log_dir,
"cloud created" + str(datetime.datetime.now()))
def add_file(self, username, file_data):
"""
add file details to the seg lists
"""
if self.__can_change__(username):
self.files.append(file_data)
db.write_in_log(
Cloud.event_log_dir,
username + "file added " + str(datetime.datetime.now()) +
"seg: " + self.name + ' file data: ' + str(file_data))
return True
return False
def add_user(self, user, password):
"""
manage adding new user to the seg - premissions
"""
if user.get_name() in self.users_and_premissions.keys():
return False
db.add_user_premission(Segment.login_db_dir, user.get_name(),
self.name)
print "added", user, "to", self.name, " premissions"
db.write_in_log(
Cloud.event_log_dir,
str(datetime.datetime.now()) + "added" + user.get_name(), "to",
self.name)
return self.add_new_premission(user.get_name(), password)
def add_user_to_seg(self, username, seg_name, password):
"""
join the user to the seg
"""
seg = self.get_seg_object(seg_name)
if seg:
print 'adding to seg........'
if seg.add_user(username, password) and username.add_seg(seg):
db.write_in_log(
Cloud.event_log_dir,
"user joined -" + str(user.get_name()) + "---" +
str(datetime.datetime.now()) + "-- from: " +
seg.get_name())
return True
return False
def add_change_premission(self, user, password, premission='W'):
"""
change premissions
"""
last_premission = self.users_and_premissions[user]
if password == self.password and last_premission != 'A' and last_premission != 'W':
self.users_and_premissions[user] = premission
db.write_in_log(
Cloud.event_log_dir, "seg premissions changed--" +
str(datetime.datetime.now()) + "--seg: " + str(self.name) +
" -- " + str(self.users_and_premissions))
return db.update_premissions(
self.cloud_dir,
self.__convert_dict_to_premission_str__(
self.users_and_premissions), self.name)
return False
def delete_user_from_seg(self, user, seg):
"""
delete the user to the seg
"""
print seg
print user.getSegments()
if seg in user.getSegments():
print 'deletingggg'
if (seg.delete_user(user.get_name()) and user.delete_seg(seg)):
db.write_in_log(
Cloud.event_log_dir,
"user exited -" + str(user.get_name()) + "---" +
str(datetime.datetime.now()) + "-- from: " +
seg.get_name())
return True
return False
def change_seg_name(self, seg_object, username, password, new_name):
"""
handle renaming segments
"""
last_name = seg_object.get_name()
if seg_object.change_table_name(username, password, new_name):
#self.segments_names.remove(last_name)
#self.segments_names.append(new_name)
print self.segments_names
self.segments[new_name] = self.segments[last_name]
del self.segments[last_name]
db.write_in_log(
Cloud.event_log_dir,
"seg name changed--" + str(datetime.datetime.now()) +
"--from: " + str(last_name) + "to: " + new_name)
return True
return False
def set_user_name(self, username, new_username):
"""
rename the username
"""
if db.rename_user(self.dir_name_login, username, new_username):
self.all_users[username].set_name(new_username)
user_segments = self.all_users[username].getSegments()
for seg in user_segments:
seg.update_username(username, new_username)
self.all_users[new_username] = self.all_users[username]
del self.all_users[username]
db.write_in_log(
Cloud.event_log_dir, "username changed -" +
str(user.get_name()) + "---" + str(datetime.datetime.now()) +
"-- from: " + username + " to: " + new_username)
return (True, self.all_users[new_username])
return False
def createNewSegment(self, name, users_and_premissions, password):
"""
add to the database and the objects(cloud, the relevant users) the seg
"""
new_seg = Segment(
self.cloud_dir, name,
self.__handle_users_premissions_protocol__(users_and_premissions),
password, False)
self.segments_names.append(name)
self.segments[name] = (new_seg)
self.add_seg_to_users(
self.__handle_users_premissions_protocol__(users_and_premissions),
new_seg)
db.write_in_log(
Cloud.event_log_dir,
"seg created--" + str(datetime.datetime.now()) + "--seg name: " +
str(name) + " premissions: " + str(users_and_premissions))
return new_seg
def __convertDataToObject_USER__(self, list_of_data):
"""
create all the users objects
"""
users_list = {}
for data in list_of_data:
if data[0] == self.admin_username:
users_list[data[0]] = (Client(data[0], self.segments.values(),
data[1], data[3], data[4]))
else:
users_list[data[0]] = (Client(
data[0],
self.get_segements_by_premissions(data[2], data[0]),
data[1], data[3], data[4]))
print users_list
db.write_in_log(
Cloud.event_log_dir, "users loaded -" +
str(datetime.datetime.now()) + "--" + str(users_list))
return users_list
def delete_file(self, user, file_name):
"""
delete file in the database
according the user premissions
"""
premission = self.users_and_premissions[user]
if premission == 'W' or premission == 'A':
if db.delete_file(self.cloud_dir, self.name, file_name):
data = filter(lambda file_data: file_data[0] == file_name,
self.files)[0]
self.files.remove(data)
db.write_in_log(
Cloud.event_log_dir,
str(datetime.datetime.now()) + 'removed from' + self.name +
" : " + str(data))
print 'removed from', self.name, " : ", data
return data
else:
return False
def change_table_name(self, username, seg_password, new_name):
"""
change table name in the object + database
"""
print self.users_and_premissions.keys()
last_name = self.name
if self.password == seg_password and self.__can_change__(username):
result = db.change_name_segment(self.cloud_dir,
Segment.login_db_dir, self.name,
new_name,
self.users_and_premissions.keys())
if result:
self.name = new_name
db.write_in_log(
Cloud.event_log_dir,
"seg name changed--" + str(datetime.datetime.now()) +
"--from: " + str(last_name) + " to: " + str(self.name))
return result
return False
def change_name_file(self, user, file_name, new_name):
"""
change file name: seg_object + database
"""
premission = self.users_and_premissions[user]
if premission == 'W' or premission == 'A':
if db.change_name_file(self.cloud_dir, self.name, file_name,
new_name):
last_file_details = filter(
lambda file_data: file_data[0] == file_name, self.files)[0]
self.files[self.files.index(last_file_details)] = (
new_name, last_file_details[1], last_file_details[2])
db.write_in_log(
Cloud.event_log_dir, "file name changed--" +
str(datetime.datetime.now()) + "--seg: " + str(self.name) +
" file: " + str(file_name) + " to: " + new_name)
return True
return False
else:
return False
def download(self, user, file_name, directory_folder):
"""
return the download path of the user, the file binary
according the Premission
"""
premission = self.users_and_premissions[user]
if premission == 'R' or premission == 'A':
command = '''SELECT file_directory,file_extension FROM ''' + str(
self.name) + ''' WHERE file_name= "''' + (file_name) + '''"'''
path = os.path.join(directory_folder, file_name)
file_data = db.getDataFromCloud(self.cloud_dir, command)
server_file_path, file_extension = str(
file_data[0][0]), file_data[0][1]
#
print server_file_path
with open((server_file_path + file_extension), "rb") as f:
file_binary = f.read()
db.write_in_log(
Cloud.event_log_dir, user + "downloaded file " +
str(datetime.datetime.now()) + 'file name: ' + file_name)
return file_binary, path + file_extension
else:
return None
def __load_segments_from_cloud__(self, cloud_dir):
"""
load from the database all the segments
"""
segments = {}
for name in self.segments_names:
print name
if name[0] != "segments_data":
command = (
'''SELECT password,users_premissions FROM segments_data WHERE segment_name= "'''
+ name[0] + '''"''')
print command
password, users_and_premissions = (db.getDataFromCloud(
cloud_dir, command)[0])
users_and_premissions = self.__handle_users_premissions_protocol__(
users_and_premissions)
segments[name[0]] = (Segment(self.cloud_dir, name[0],
users_and_premissions, password,
True))
print segments
db.write_in_log(
Cloud.event_log_dir, "segs loaded -" +
str(datetime.datetime.now()) + "--" + str(segments))
return segments
