def get_repo_info(repo):
repo_owner = seafile_api.get_repo_owner(repo.repo_id)
if not repo_owner:
try:
org_repo_owner = seafile_api.get_org_repo_owner(repo.repo_id)
except Exception:
org_repo_owner = None
owner = repo_owner or org_repo_owner or ''
result = {}
result['id'] = repo.repo_id
result['name'] = repo.repo_name
result['owner'] = owner
result['owner_email'] = owner
result['owner_name'] = email2nickname(owner)
result['owner_contact_email'] = email2contact_email(owner)
result['size'] = repo.size
result['size_formatted'] = filesizeformat(repo.size)
result['encrypted'] = repo.encrypted
result['file_count'] = repo.file_count
result['status'] = normalize_repo_status_code(repo.status)
if '@seafile_group' in owner:
group_id = get_group_id_by_repo_owner(owner)
result['group_name'] = group_id_to_name(group_id)
return result
def get(self, request, repo_id):
""" Return repo info
Permission checking:
1. all authenticated user can perform this action.
"""
# resource check
repo = seafile_api.get_repo(repo_id)
if not repo:
error_msg = 'Library %s not found.' % repo_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
# permission check
permission = check_folder_permission(request, repo_id, '/')
if permission is None:
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
username = request.user.username
lib_need_decrypt = False
if repo.encrypted \
and not seafile_api.is_password_set(repo.id, username):
lib_need_decrypt = True
repo_owner = get_repo_owner(request, repo_id)
try:
has_been_shared_out = repo_has_been_shared_out(request, repo_id)
except Exception as e:
has_been_shared_out = False
logger.error(e)
result = {
"repo_id": repo.id,
"repo_name": repo.name,
"owner_email": repo_owner,
"owner_name": email2nickname(repo_owner),
"owner_contact_email": email2contact_email(repo_owner),
"size": repo.size,
"encrypted": repo.encrypted,
"file_count": repo.file_count,
"permission": permission,
"no_quota": True if seafile_api.check_quota(repo_id) < 0 else False,
"is_admin": is_repo_admin(username, repo_id),
"is_virtual": repo.is_virtual,
"has_been_shared_out": has_been_shared_out,
"lib_need_decrypt": lib_need_decrypt,
"last_modified": timestamp_to_isoformat_timestr(repo.last_modify),
"status": normalize_repo_status_code(repo.status),
}
return Response(result)
def get(self, request, org_id, email):
"""Org admin list repos by shared to user
"""
# resource check
org_id = int(org_id)
if not ccnet_api.get_org_by_id(org_id):
error_msg = 'Organization %s not found.' % org_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
err_msg = 'User %s not found.' % email
return api_error(status.HTTP_404_NOT_FOUND, err_msg)
# permission check
if not ccnet_api.org_user_exists(org_id, email):
err_msg = _('User %s not found in organization.') % email
return api_error(status.HTTP_404_NOT_FOUND, err_msg)
# list beshared repos
repo_info_list = list()
beshared_repos = seafile_api.get_org_share_in_repo_list(
org_id, email, -1, -1)
for r in beshared_repos:
owner_email = r.user
group_name = ''
is_group_owned_repo = False
if '@seafile_group' in owner_email:
is_group_owned_repo = True
group_id = get_group_id_by_repo_owner(owner_email)
group_name = group_id_to_name(group_id)
owner_name = group_name if is_group_owned_repo else \
email2nickname(owner_email)
owner_contact_email = '' if is_group_owned_repo else \
email2contact_email(owner_email)
repo_info = {
"repo_id": r.repo_id,
"repo_name": r.repo_name,
"last_modified": timestamp_to_isoformat_timestr(r.last_modify),
"modifier_email": r.last_modifier,
"owner_email": owner_email,
"owner_name": owner_name,
"owner_contact_email": owner_contact_email,
"size": r.size,
"encrypted": r.encrypted,
"permission": r.permission,
"status": normalize_repo_status_code(r.status),
}
repo_info_list.append(repo_info)
return Response({'repo_list': repo_info_list})
def get(self, request, email):
""" List 'all' libraries shared to a user
Permission checking:
1. only admin can perform this action.
"""
if not request.user.admin_permissions.can_manage_user():
return api_error(status.HTTP_403_FORBIDDEN, 'Permission denied.')
try:
User.objects.get(email=email)
except User.DoesNotExist as e:
logger.error(e)
error_msg = 'User %s not found.' % email
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
try:
beshared_repos = seafile_api.get_share_in_repo_list(email, -1, -1)
except Exception as e:
logger.error(e)
error_msg = 'Internal Server Error'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
# Use dict to reduce memcache fetch cost in large for-loop.
nickname_dict = {}
owner_set = set([x.user for x in beshared_repos])
for email in owner_set:
if email not in nickname_dict:
if '@seafile_group' in email:
group_id = get_group_id_by_repo_owner(email)
group_name = group_id_to_name(group_id)
nickname_dict[email] = group_name
else:
nickname_dict[email] = email2nickname(email)
repos_info = []
for repo in beshared_repos:
repo_info = {}
repo_info['id'] = repo.repo_id
repo_info['name'] = repo.repo_name
repo_info['owner_email'] = repo.user
repo_info['owner_name'] = nickname_dict.get(repo.user, '')
repo_info['size'] = repo.size
repo_info['encrypted'] = repo.encrypted
repo_info['file_count'] = repo.file_count
repo_info['status'] = normalize_repo_status_code(repo.status)
repo_info['last_modify'] = timestamp_to_isoformat_timestr(
repo.last_modify)
repos_info.append(repo_info)
return Response({'repo_list': repos_info})
def get(self, request, org_id, email):
"""Org admin list user owned repos
"""
# resource check
org_id = int(org_id)
if not ccnet_api.get_org_by_id(org_id):
error_msg = 'Organization %s not found.' % org_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
try:
user = User.objects.get(email=email)
except User.DoesNotExist:
err_msg = 'User %s not found.' % email
return api_error(status.HTTP_404_NOT_FOUND, err_msg)
# permission check
if not ccnet_api.org_user_exists(org_id, email):
err_msg = _('User %s not found in organization.') % email
return api_error(status.HTTP_404_NOT_FOUND, err_msg)
# list repos
repo_info_list = list()
owned_repos = seafile_api.get_org_owned_repo_list(org_id, email)
for r in owned_repos:
# do not return virtual repos
if r.is_virtual:
continue
repo_info = {
"repo_id": r.id,
"repo_name": r.name,
"owner_email": email,
"owner_name": email2nickname(email),
"owner_contact_email": email2contact_email(email),
"last_modified": timestamp_to_isoformat_timestr(r.last_modify),
"modifier_email": r.last_modifier,
"size": r.size,
"encrypted": r.encrypted,
"permission":
'rw', # Always have read-write permission to owned repo
"status": normalize_repo_status_code(r.status),
}
repo_info_list.append(repo_info)
return Response({'repo_list': repo_info_list})
def get(self, request, format=None):
""" Search library by name.
Permission checking:
1. only admin can perform this action.
"""
if not request.user.admin_permissions.can_manage_library():
return api_error(status.HTTP_403_FORBIDDEN, 'Permission denied.')
query_str = request.GET.get('query', '').lower().strip()
if not query_str:
error_msg = 'query invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
repos = seafile_api.search_repos_by_name(query_str)
default_repo_id = get_system_default_repo_id()
repos = [r for r in repos if not r.is_virtual]
repos = [r for r in repos if r.repo_id != default_repo_id]
email_dict = {}
name_dict = {}
contact_email_dict = {}
for repo in repos:
# get owner email
repo_id = repo.repo_id
repo_owner = seafile_api.get_repo_owner(repo_id)
if not repo_owner:
try:
org_repo_owner = seafile_api.get_org_repo_owner(repo_id)
except Exception:
org_repo_owner = ''
owner_email = repo_owner or org_repo_owner or ''
if repo_id not in email_dict:
email_dict[repo_id] = owner_email
# get owner name
if repo_id not in name_dict:
# is department library
if '@seafile_group' in owner_email:
group_id = get_group_id_by_repo_owner(owner_email)
owner_name = group_id_to_name(group_id)
else:
owner_name = email2nickname(owner_email)
name_dict[repo_id] = owner_name
# get owner contact_email
if repo_id not in contact_email_dict:
if '@seafile_group' in owner_email:
owner_contact_email = ''
else:
owner_contact_email = email2contact_email(owner_email)
contact_email_dict[repo_id] = owner_contact_email
result = []
for repo in repos:
info = {}
info['id'] = repo.repo_id
info['name'] = repo.repo_name
info['owner_email'] = email_dict.get(repo.repo_id, '')
info['owner_name'] = name_dict.get(repo.repo_id, '')
info['owner_contact_email'] = contact_email_dict.get(
repo.repo_id, '')
info['size'] = repo.size
info['encrypted'] = repo.encrypted
info['file_count'] = repo.file_count
info['status'] = normalize_repo_status_code(repo.status)
result.append(info)
return Response({"repo_list": result})
def get(self, request):
""" Return repos user can access.
Permission checking:
1. all authenticated user can perform this action.
"""
filter_by = {
'mine': False,
'shared': False,
'group': False,
'public': False,
}
request_type_list = request.GET.getlist('type', "")
if not request_type_list:
# set all to True, no filter applied
filter_by = filter_by.fromkeys(filter_by.iterkeys(), True)
for request_type in request_type_list:
request_type = request_type.strip()
filter_by[request_type] = True
email = request.user.username
# Use dict to reduce memcache fetch cost in large for-loop.
contact_email_dict = {}
nickname_dict = {}
org_id = None
if is_org_context(request):
org_id = request.user.org.org_id
try:
starred_repos = UserStarredFiles.objects.get_starred_repos_by_user(
email)
starred_repo_id_list = [item.repo_id for item in starred_repos]
except Exception as e:
logger.error(e)
starred_repo_id_list = []
repo_info_list = []
if filter_by['mine']:
if org_id:
owned_repos = seafile_api.get_org_owned_repo_list(
org_id, email, ret_corrupted=True)
else:
owned_repos = seafile_api.get_owned_repo_list(
email, ret_corrupted=True)
# Reduce memcache fetch ops.
modifiers_set = set([x.last_modifier for x in owned_repos])
for e in modifiers_set:
if e not in contact_email_dict:
contact_email_dict[e] = email2contact_email(e)
if e not in nickname_dict:
nickname_dict[e] = email2nickname(e)
owned_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify))
for r in owned_repos:
# do not return virtual repos
if r.is_virtual:
continue
repo_info = {
"type":
"mine",
"repo_id":
r.id,
"repo_name":
r.name,
"owner_email":
email,
"owner_name":
email2nickname(email),
"owner_contact_email":
email2contact_email(email),
"last_modified":
timestamp_to_isoformat_timestr(r.last_modify),
"modifier_email":
r.last_modifier,
"modifier_name":
nickname_dict.get(r.last_modifier, ''),
"modifier_contact_email":
contact_email_dict.get(r.last_modifier, ''),
"size":
r.size,
"encrypted":
r.encrypted,
"permission":
'rw', # Always have read-write permission to owned repo
"starred":
r.repo_id in starred_repo_id_list,
"status":
normalize_repo_status_code(r.status),
}
if is_pro_version() and ENABLE_STORAGE_CLASSES:
repo_info['storage_name'] = r.storage_name
repo_info['storage_id'] = r.storage_id
repo_info_list.append(repo_info)
if filter_by['shared']:
if org_id:
shared_repos = seafile_api.get_org_share_in_repo_list(
org_id, email, -1, -1)
else:
shared_repos = seafile_api.get_share_in_repo_list(
email, -1, -1)
repos_with_admin_share_to = ExtraSharePermission.objects.\
get_repos_with_admin_permission(email)
# Reduce memcache fetch ops.
owners_set = set([x.user for x in shared_repos])
modifiers_set = set([x.last_modifier for x in shared_repos])
for e in owners_set | modifiers_set:
if e not in contact_email_dict:
contact_email_dict[e] = email2contact_email(e)
if e not in nickname_dict:
nickname_dict[e] = email2nickname(e)
shared_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify))
for r in shared_repos:
owner_email = r.user
group_name = ''
is_group_owned_repo = False
if '@seafile_group' in owner_email:
is_group_owned_repo = True
group_id = get_group_id_by_repo_owner(owner_email)
group_name = group_id_to_name(group_id)
owner_name = group_name if is_group_owned_repo else \
nickname_dict.get(owner_email, '')
owner_contact_email = '' if is_group_owned_repo else \
contact_email_dict.get(owner_email, '')
repo_info = {
"type":
"shared",
"repo_id":
r.repo_id,
"repo_name":
r.repo_name,
"last_modified":
timestamp_to_isoformat_timestr(r.last_modify),
"modifier_email":
r.last_modifier,
"modifier_name":
nickname_dict.get(r.last_modifier, ''),
"modifier_contact_email":
contact_email_dict.get(r.last_modifier, ''),
"owner_email":
owner_email,
"owner_name":
owner_name,
"owner_contact_email":
owner_contact_email,
"size":
r.size,
"encrypted":
r.encrypted,
"permission":
r.permission,
"starred":
r.repo_id in starred_repo_id_list,
"status":
normalize_repo_status_code(r.status),
}
if r.repo_id in repos_with_admin_share_to:
repo_info['is_admin'] = True
else:
repo_info['is_admin'] = False
repo_info_list.append(repo_info)
if filter_by['group']:
if org_id:
group_repos = seafile_api.get_org_group_repos_by_user(
email, org_id)
else:
group_repos = seafile_api.get_group_repos_by_user(email)
group_repos.sort(lambda x, y: cmp(y.last_modify, x.last_modify))
# Reduce memcache fetch ops.
share_from_set = set([x.user for x in group_repos])
modifiers_set = set([x.last_modifier for x in group_repos])
for e in modifiers_set | share_from_set:
if e not in contact_email_dict:
contact_email_dict[e] = email2contact_email(e)
if e not in nickname_dict:
nickname_dict[e] = email2nickname(e)
for r in group_repos:
repo_info = {
"type":
"group",
"group_id":
r.group_id,
"group_name":
r.group_name,
"repo_id":
r.repo_id,
"repo_name":
r.repo_name,
"last_modified":
timestamp_to_isoformat_timestr(r.last_modify),
"modifier_email":
r.last_modifier,
"modifier_name":
nickname_dict.get(r.last_modifier, ''),
"modifier_contact_email":
contact_email_dict.get(r.last_modifier, ''),
"size":
r.size,
"encrypted":
r.encrypted,
"permission":
r.permission,
"starred":
r.repo_id in starred_repo_id_list,
"status":
normalize_repo_status_code(r.status),
}
repo_info_list.append(repo_info)
if filter_by['public'] and request.user.permissions.can_view_org():
public_repos = list_inner_pub_repos(request)
# get repo id owner dict
all_repo_owner = []
repo_id_owner_dict = {}
for repo in public_repos:
repo_id = repo.repo_id
if repo_id not in repo_id_owner_dict:
repo_owner = get_repo_owner(request, repo_id)
all_repo_owner.append(repo_owner)
repo_id_owner_dict[repo_id] = repo_owner
# Reduce memcache fetch ops.
owner_set = set(all_repo_owner)
share_from_set = set([x.user for x in public_repos])
modifiers_set = set([x.last_modifier for x in public_repos])
for e in modifiers_set | share_from_set | owner_set:
if e not in contact_email_dict:
contact_email_dict[e] = email2contact_email(e)
if e not in nickname_dict:
nickname_dict[e] = email2nickname(e)
for r in public_repos:
repo_owner = repo_id_owner_dict[r.repo_id]
repo_info = {
"type":
"public",
"repo_id":
r.repo_id,
"repo_name":
r.repo_name,
"last_modified":
timestamp_to_isoformat_timestr(r.last_modify),
"modifier_email":
r.last_modifier,
"modifier_name":
nickname_dict.get(r.last_modifier, ''),
"modifier_contact_email":
contact_email_dict.get(r.last_modifier, ''),
"owner_email":
repo_owner,
"owner_name":
nickname_dict.get(repo_owner, ''),
"owner_contact_email":
contact_email_dict.get(repo_owner, ''),
"size":
r.size,
"encrypted":
r.encrypted,
"permission":
r.permission,
"starred":
r.repo_id in starred_repo_id_list,
"status":
normalize_repo_status_code(r.status),
}
repo_info_list.append(repo_info)
utc_dt = datetime.datetime.utcnow()
timestamp = utc_dt.strftime('%Y-%m-%d %H:%M:%S')
org_id = request.user.org.org_id if is_org_context(request) else -1
try:
send_message('seahub.stats',
'user-login\t%s\t%s\t%s' % (email, timestamp, org_id))
except Exception as e:
logger.error('Error when sending user-login message: %s' % str(e))
return Response({'repos': repo_info_list})
