def prepare_starred_files(files):
array = []
for f in files:
sfile = {'org' : f.org_id,
'repo' : f.repo.id,
'repo_id' : f.repo.id,
'repo_name' : f.repo.name,
'path' : f.path,
'icon_path' : file_icon_filter(f.path),
'file_name' : os.path.basename(f.path),
'mtime' : f.last_modified,
'mtime_relative': translate_seahub_time(f.last_modified),
'dir' : f.is_dir,
'repo_encrypted' : f.repo.encrypted
}
if not f.is_dir:
try:
file_id = seafile_api.get_file_id_by_path(f.repo.id, f.path)
sfile['oid'] = file_id
sfile['size'] = get_file_size(f.repo.store_id, f.repo.version, file_id)
except SearpcError as e:
logger.error(e)
pass
array.append(sfile)
return array
def prepare_starred_files(files):
array = []
for f in files:
sfile = {'org' : f.org_id,
'repo' : f.repo.id,
'repo_id' : f.repo.id,
'repo_name' : f.repo.name,
'path' : f.path,
'icon_path' : file_icon_filter(f.path),
'file_name' : os.path.basename(f.path),
'mtime' : f.last_modified,
'mtime_relative': translate_seahub_time(f.last_modified),
'dir' : f.is_dir,
'repo_encrypted' : f.repo.encrypted
}
if not f.is_dir:
try:
file_id = seafile_api.get_file_id_by_path(f.repo.id, f.path)
sfile['oid'] = file_id
sfile['size'] = get_file_size(f.repo.store_id, f.repo.version, file_id)
except SearpcError as e:
logger.error(e)
pass
array.append(sfile)
return array
def get(self, request, format=None):
if not EVENTS_ENABLED:
events = None
return api_error(status.HTTP_404_NOT_FOUND, 'Events not enabled.')
try:
page = int(request.GET.get('page', ''))
except ValueError:
page = 1
try:
per_page = int(request.GET.get('per_page', ''))
except ValueError:
per_page = 25
start = (page - 1) * per_page
count = per_page
email = request.user.username
events = get_user_activities(email, start, count)
events_list = []
for e in events:
d = dict(op_type=e.op_type)
d['repo_id'] = e.repo_id
d['repo_name'] = e.repo_name
d['obj_type'] = e.obj_type
d['commit_id'] = e.commit_id
d['path'] = e.path
d['name'] = '' if e.path == '/' else os.path.basename(e.path)
d['author_email'] = e.op_user
d['author_name'] = email2nickname(e.op_user)
d['author_contact_email'] = email2contact_email(e.op_user)
try:
size = int(request.GET.get('size', 36))
except ValueError as e:
size = 36
url, is_default, date_uploaded = api_avatar_url(e.op_user, size)
d['avatar_url'] = request.build_absolute_uri(url)
d['time_relative'] = translate_seahub_time(
utc_to_local(e.timestamp))
if e.op_type == 'clean-up-trash':
d['days'] = e.days
elif e.op_type == 'rename' and e.obj_type == 'repo':
d['old_repo_name'] = e.old_repo_name
elif e.op_type == 'move' and e.obj_type in ['dir', 'file']:
d['old_path'] = e.old_path
elif e.op_type == 'rename' and e.obj_type in ['dir', 'file']:
d['old_path'] = e.old_path
d['old_name'] = os.path.basename(e.old_path)
events_list.append(d)
ret = {'events': events_list}
return Response(ret)
def get(self, request):
""" List all groups.
"""
org_id = None
username = request.user.username
if is_org_context(request):
org_id = request.user.org.org_id
user_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
user_groups = seaserv.get_personal_groups_by_user(username)
try:
size = int(request.GET.get('avatar_size', GROUP_AVATAR_DEFAULT_SIZE))
except ValueError:
size = GROUP_AVATAR_DEFAULT_SIZE
try:
with_repos = int(request.GET.get('with_repos', 0))
except ValueError:
with_repos = 0
if with_repos not in (0, 1):
error_msg = _(u'Argument can only be 0 or 1')
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
groups = []
for g in user_groups:
group_info = get_group_info(request, g.id , size)
if with_repos:
if org_id:
group_repos = seafile_api.get_org_group_repos(org_id, g.id)
else:
group_repos = seafile_api.get_repos_by_group(g.id)
repos = []
for r in group_repos:
repo = {
"id": r.id,
"name": r.name,
"desc": r.desc,
"size": r.size,
"size_formatted": filesizeformat(r.size),
"mtime": r.last_modified,
"mtime_relative": translate_seahub_time(r.last_modified),
"encrypted": r.encrypted,
"permission": r.permission,
"owner": r.user,
"owner_nickname": email2nickname(r.user),
"share_from_me": True if username == r.user else False,
}
repos.append(repo)
group_info['repos'] = repos
groups.append(group_info)
return Response(groups)
def get(self, request):
""" List all groups.
"""
org_id = None
username = request.user.username
if is_org_context(request):
org_id = request.user.org.org_id
user_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
user_groups = seaserv.get_personal_groups_by_user(username)
try:
avatar_size = int(
request.GET.get('avatar_size', GROUP_AVATAR_DEFAULT_SIZE))
except ValueError:
avatar_size = GROUP_AVATAR_DEFAULT_SIZE
try:
with_repos = int(request.GET.get('with_repos', 0))
except ValueError:
with_repos = 0
if with_repos not in (0, 1):
error_msg = 'with_repos invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
groups = []
for g in user_groups:
group_info = get_group_info(request, g.id, avatar_size)
if with_repos:
if org_id:
group_repos = seafile_api.get_org_group_repos(org_id, g.id)
else:
group_repos = seafile_api.get_repos_by_group(g.id)
repos = []
for r in group_repos:
repo = {
"id": r.id,
"name": r.name,
"size": r.size,
"size_formatted": filesizeformat(r.size),
"mtime": r.last_modified,
"mtime_relative":
translate_seahub_time(r.last_modified),
"encrypted": r.encrypted,
"permission": r.permission,
"owner": r.user,
"owner_name": email2nickname(r.user),
}
repos.append(repo)
group_info['repos'] = repos
groups.append(group_info)
return Response(groups)
def get(self, request):
""" List all groups.
"""
org_id = None
username = request.user.username
if is_org_context(request):
org_id = request.user.org.org_id
user_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
user_groups = ccnet_api.get_groups(username, return_ancestors=True)
try:
avatar_size = int(request.GET.get('avatar_size', GROUP_AVATAR_DEFAULT_SIZE))
except ValueError:
avatar_size = GROUP_AVATAR_DEFAULT_SIZE
try:
with_repos = int(request.GET.get('with_repos', 0))
except ValueError:
with_repos = 0
if with_repos not in (0, 1):
error_msg = 'with_repos invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
groups = []
if with_repos:
gids = [g.id for g in user_groups]
admin_info = ExtraGroupsSharePermission.objects.batch_get_repos_with_admin_permission(gids)
for g in user_groups:
group_info = get_group_info(request, g.id, avatar_size)
if with_repos:
if org_id:
group_repos = seafile_api.get_org_group_repos(org_id, g.id)
else:
group_repos = seafile_api.get_repos_by_group(g.id)
repos = []
# get repo id owner dict
all_repo_owner = []
repo_id_owner_dict = {}
for repo in group_repos:
repo_id = 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
# Use dict to reduce memcache fetch cost in large for-loop.
name_dict = {}
contact_email_dict = {}
for email in all_repo_owner:
if email not in name_dict:
if '@seafile_group' in email:
group_id = get_group_id_by_repo_owner(email)
group_name= group_id_to_name(group_id)
name_dict[email] = group_name
else:
name_dict[email] = email2nickname(email)
if email not in contact_email_dict:
if '@seafile_group' in email:
contact_email_dict[email] = ''
else:
contact_email_dict[email] = email2contact_email(email)
for r in group_repos:
repo_owner = repo_id_owner_dict.get(r.id, r.user)
repo = {
"id": r.id,
"repo_id": r.id,
"name": r.name,
"repo_name": r.name,
"size": r.size,
"size_formatted": filesizeformat(r.size),
"mtime": r.last_modified,
"mtime_relative": translate_seahub_time(r.last_modified),
"last_modified": timestamp_to_isoformat_timestr(r.last_modified),
"encrypted": r.encrypted,
"permission": r.permission,
"owner": repo_owner,
"owner_email": repo_owner,
"owner_name": name_dict.get(repo_owner, ''),
"owner_contact_email": contact_email_dict.get(repo_owner, ''),
"is_admin": (r.id, g.id) in admin_info
}
repos.append(repo)
group_info['repos'] = repos
groups.append(group_info)
return Response(groups)
def list_lib_dir(request, repo_id):
'''
New ajax API for list library directory
'''
content_type = 'application/json; charset=utf-8'
result = {}
repo = get_repo(repo_id)
if not repo:
err_msg = _(u'Library does not exist.')
return HttpResponse(json.dumps({'error': err_msg}),
status=400, content_type=content_type)
username = request.user.username
path = request.GET.get('p', '/')
if path[-1] != '/':
path = path + '/'
# perm for current dir
user_perm = check_folder_permission(request, repo.id, path)
if user_perm is None:
err_msg = _(u'Permission denied.')
return HttpResponse(json.dumps({'error': err_msg}),
status=403, content_type=content_type)
if repo.encrypted \
and not seafile_api.is_password_set(repo.id, username):
err_msg = _(u'Library is encrypted.')
return HttpResponse(json.dumps({'error': err_msg, 'lib_need_decrypt': True}),
status=403, content_type=content_type)
head_commit = get_commit(repo.id, repo.version, repo.head_cmmt_id)
if not head_commit:
err_msg = _(u'Error: no head commit id')
return HttpResponse(json.dumps({'error': err_msg}),
status=500, content_type=content_type)
dir_list = []
file_list = []
try:
dir_id = seafile_api.get_dir_id_by_path(repo.id, path)
except SearpcError as e:
logger.error(e)
err_msg = 'Internal Server Error'
return HttpResponse(json.dumps({'error': err_msg}),
status=500, content_type=content_type)
if not dir_id:
err_msg = 'Folder not found.'
return HttpResponse(json.dumps({'error': err_msg}),
status=404, content_type=content_type)
dirs = seafserv_threaded_rpc.list_dir_with_perm(repo_id, path, dir_id,
username, -1, -1)
starred_files = get_dir_starred_files(username, repo_id, path)
for dirent in dirs:
dirent.last_modified = dirent.mtime
if stat.S_ISDIR(dirent.mode):
dpath = posixpath.join(path, dirent.obj_name)
if dpath[-1] != '/':
dpath += '/'
dir_list.append(dirent)
else:
if repo.version == 0:
file_size = seafile_api.get_file_size(repo.store_id, repo.version, dirent.obj_id)
else:
file_size = dirent.size
dirent.file_size = file_size if file_size else 0
dirent.starred = False
fpath = posixpath.join(path, dirent.obj_name)
if fpath in starred_files:
dirent.starred = True
file_list.append(dirent)
if is_org_context(request):
repo_owner = seafile_api.get_org_repo_owner(repo.id)
else:
repo_owner = seafile_api.get_repo_owner(repo.id)
result["is_repo_owner"] = False
result["has_been_shared_out"] = False
if repo_owner == username:
result["is_repo_owner"] = True
try:
if is_org_context(request):
org_id = request.user.org.org_id
is_inner_org_pub_repo = False
# check if current repo is pub-repo
org_pub_repos = seafile_api.list_org_inner_pub_repos_by_owner(
org_id, username)
for org_pub_repo in org_pub_repos:
if repo_id == org_pub_repo.id:
is_inner_org_pub_repo = True
break
if seafile_api.list_org_repo_shared_group(org_id, username, repo_id) or \
seafile_api.list_org_repo_shared_to(org_id, username, repo_id) or \
is_inner_org_pub_repo:
result["has_been_shared_out"] = True
else:
if seafile_api.list_repo_shared_to(username, repo_id) or \
seafile_api.list_repo_shared_group_by_user(username, repo_id) or \
(not request.cloud_mode and seafile_api.is_inner_pub_repo(repo_id)):
result["has_been_shared_out"] = True
except Exception as e:
logger.error(e)
result["is_virtual"] = repo.is_virtual
result["repo_name"] = repo.name
result["user_perm"] = user_perm
# check quota for fileupload
result["no_quota"] = True if seaserv.check_quota(repo.id) < 0 else False
result["encrypted"] = repo.encrypted
dirent_list = []
for d in dir_list:
d_ = {}
d_['is_dir'] = True
d_['obj_name'] = d.obj_name
d_['last_modified'] = d.last_modified
d_['last_update'] = translate_seahub_time(d.last_modified)
d_['p_dpath'] = posixpath.join(path, d.obj_name)
d_['perm'] = d.permission # perm for sub dir in current dir
dirent_list.append(d_)
size = int(request.GET.get('thumbnail_size', THUMBNAIL_DEFAULT_SIZE))
for f in file_list:
f_ = {}
f_['is_file'] = True
f_['file_icon'] = file_icon_filter(f.obj_name)
f_['obj_name'] = f.obj_name
f_['last_modified'] = f.last_modified
f_['last_update'] = translate_seahub_time(f.last_modified)
f_['starred'] = f.starred
f_['file_size'] = filesizeformat(f.file_size)
f_['obj_id'] = f.obj_id
f_['perm'] = f.permission # perm for file in current dir
file_type, file_ext = get_file_type_and_ext(f.obj_name)
if file_type == IMAGE:
f_['is_img'] = True
if not repo.encrypted and ENABLE_THUMBNAIL and \
os.path.exists(os.path.join(THUMBNAIL_ROOT, str(size), f.obj_id)):
file_path = posixpath.join(path, f.obj_name)
src = get_thumbnail_src(repo_id, size, file_path)
f_['encoded_thumbnail_src'] = urlquote(src)
if is_pro_version():
f_['is_locked'] = True if f.is_locked else False
f_['lock_owner'] = f.lock_owner
f_['lock_owner_name'] = email2nickname(f.lock_owner)
if username == f.lock_owner:
f_['locked_by_me'] = True
else:
f_['locked_by_me'] = False
dirent_list.append(f_)
result["dirent_list"] = dirent_list
return HttpResponse(json.dumps(result), content_type=content_type)
def get(self, request, name=None):
username = request.user.username
org_id = request.user.org.org_id if is_org_context(request) else None
owned_repos, shared_repos, groups_repos, public_repos = get_user_repos(
username, org_id=org_id)
repo_id_list =\
[repo.id for repo in owned_repos] + \
[repo.id for repo in shared_repos] + \
[repo.id for repo in groups_repos] + \
[repo.id for repo in public_repos]
if name is None:
def with_quotes(s):
return "'" + s + "'"
# sql = """
# SELECT DISTINCT t.* FROM tags_tags t
# LEFT JOIN tags_filetag f ON t.id = f.tag_id
# LEFT JOIN tags_fileuuidmap m ON f.uuid_id = m.uuid
# WHERE m.repo_id IN (%(repo_id_list)s)
# """
# tag_list = Tags.objects.raw(sql, {'repo_id_list': repo_id_list})
repo_id_text = ', '.join(map(with_quotes, repo_id_list))
sql = """
SELECT DISTINCT t.* FROM tags_tags t
LEFT JOIN tags_filetag f ON t.id = f.tag_id
LEFT JOIN tags_fileuuidmap m ON f.uuid_id = m.uuid
WHERE m.repo_id IN ({})
""".format(repo_id_text)
tag_list = Tags.objects.raw(sql)
tag_list = [tag.to_dict() for tag in tag_list]
return Response(tag_list, status=status.HTTP_200_OK)
else:
tag = get_object_or_404(Tags, name=name)
fileuuidmap_list = tag.fileuuidmap_set.all()
repo = None
dir_list = []
file_list = []
for fileuuidmap in fileuuidmap_list:
if repo is None or repo.id != fileuuidmap.repo_id:
repo = seafile_api.get_repo(fileuuidmap.repo_id)
fullpath = posixpath.join(fileuuidmap.parent_path,
fileuuidmap.filename)
dirent = seafile_api.get_dirent_by_path(
fileuuidmap.repo_id, fullpath)
dirent.repo_id = repo.id
dirent.parent_path = fileuuidmap.parent_path
dirent.fullpath = fullpath
dirent.last_modified = dirent.mtime
if stat.S_ISDIR(dirent.mode):
dir_list.append(dirent)
else:
if repo.version == 0:
file_size = seafile_api.get_file_size(
repo.store_id, repo.version, dirent.obj_id)
else:
file_size = dirent.size
dirent.file_size = file_size if file_size else 0
can_preview, err_msg = can_preview_file(
dirent.obj_name, file_size, repo)
dirent.can_preview = can_preview
file_list.append(dirent)
dirent_list = []
for d in dir_list:
d_ = {
'is_dir': True,
'obj_name': d.obj_name,
'last_modified': d.last_modified,
'last_update': translate_seahub_time(d.last_modified),
'p_dpath': d.fullpath,
'perm': d.permission,
'repo_id': d.repo_id,
'parent_path': d.parent_path,
}
dirent_list.append(d_)
size = int(
request.GET.get('thumbnail_size', THUMBNAIL_DEFAULT_SIZE))
for f in file_list:
f_ = {
'is_file': True,
'obj_name': f.obj_name,
'last_modified': f.last_modified,
'last_update': translate_seahub_time(f.last_modified),
'file_size': filesizeformat(f.file_size),
'obj_id': f.obj_id,
'perm': f.permission,
'can_preview': f.can_preview,
'repo_id': f.repo_id,
'parent_path': f.parent_path,
}
if not repo.encrypted and ENABLE_THUMBNAIL:
file_ext = os.path.splitext(f.obj_name)[1][1:].lower()
file_type = FILEEXT_TYPE_MAP.get(file_ext)
if file_type == IMAGE:
f_['is_img'] = True
if file_type == VIDEO and ENABLE_VIDEO_THUMBNAIL:
f_['is_video'] = True
if file_type == IMAGE or file_type == VIDEO and ENABLE_VIDEO_THUMBNAIL:
thumbnail_file_path = os.path.join(
THUMBNAIL_ROOT, str(size), f.obj_id)
thumbnail_exist = os.path.exists(thumbnail_file_path)
if thumbnail_exist:
src = get_thumbnail_src(f.repo_id, size,
f.fullpath)
f_['encoded_thumbnail_src'] = urlquote(src)
dirent_list.append(f_)
return Response(dirent_list, status=status.HTTP_200_OK)
def list_lib_dir(request, repo_id):
'''
New ajax API for list library directory
'''
content_type = 'application/json; charset=utf-8'
result = {}
repo = get_repo(repo_id)
if not repo:
err_msg = _('Library does not exist.')
return HttpResponse(json.dumps({'error': err_msg}),
status=400,
content_type=content_type)
username = request.user.username
path = request.GET.get('p', '/')
path = normalize_dir_path(path)
dir_id = seafile_api.get_dir_id_by_path(repo.id, path)
if not dir_id:
err_msg = 'Folder not found.'
return HttpResponse(json.dumps({'error': err_msg}),
status=404,
content_type=content_type)
# perm for current dir
user_perm = check_folder_permission(request, repo_id, path)
if not user_perm:
return convert_repo_path_when_can_not_view_folder(
request, repo_id, path)
if repo.encrypted \
and not seafile_api.is_password_set(repo.id, username):
err_msg = _('Library is encrypted.')
return HttpResponse(json.dumps({
'error': err_msg,
'lib_need_decrypt': True
}),
status=403,
content_type=content_type)
head_commit = get_commit(repo.id, repo.version, repo.head_cmmt_id)
if not head_commit:
err_msg = _('Error: no head commit id')
return HttpResponse(json.dumps({'error': err_msg}),
status=500,
content_type=content_type)
dir_list = []
file_list = []
dirs = seafserv_threaded_rpc.list_dir_with_perm(repo_id, path, dir_id,
username, -1, -1)
starred_files = get_dir_starred_files(username, repo_id, path)
for dirent in dirs:
dirent.last_modified = dirent.mtime
if stat.S_ISDIR(dirent.mode):
dpath = posixpath.join(path, dirent.obj_name)
if dpath[-1] != '/':
dpath += '/'
dir_list.append(dirent)
else:
if repo.version == 0:
file_size = seafile_api.get_file_size(repo.store_id,
repo.version,
dirent.obj_id)
else:
file_size = dirent.size
dirent.file_size = file_size if file_size else 0
dirent.starred = False
fpath = posixpath.join(path, dirent.obj_name)
if fpath in starred_files:
dirent.starred = True
file_list.append(dirent)
if is_org_context(request):
repo_owner = seafile_api.get_org_repo_owner(repo.id)
else:
repo_owner = seafile_api.get_repo_owner(repo.id)
result["repo_owner"] = repo_owner
result["is_repo_owner"] = False
result["has_been_shared_out"] = False
result["is_admin"] = is_repo_admin(username, repo_id)
if repo_owner == username:
result["is_repo_owner"] = True
try:
result["has_been_shared_out"] = repo_has_been_shared_out(
request, repo_id)
except Exception as e:
logger.error(e)
if result["is_admin"]:
result["has_been_shared_out"] = True
result["is_virtual"] = repo.is_virtual
result["repo_name"] = repo.name
result["user_perm"] = user_perm
# check quota for fileupload
result["no_quota"] = True if seaserv.check_quota(repo.id) < 0 else False
result["encrypted"] = repo.encrypted
dirent_list = []
for d in dir_list:
d_ = {}
d_['is_dir'] = True
d_['obj_name'] = d.obj_name
d_['last_modified'] = d.last_modified
d_['last_update'] = translate_seahub_time(d.last_modified)
d_['p_dpath'] = posixpath.join(path, d.obj_name)
d_['perm'] = d.permission # perm for sub dir in current dir
dirent_list.append(d_)
size = int(request.GET.get('thumbnail_size', THUMBNAIL_DEFAULT_SIZE))
for f in file_list:
f_ = {}
f_['is_file'] = True
f_['obj_name'] = f.obj_name
f_['last_modified'] = f.last_modified
f_['last_update'] = translate_seahub_time(f.last_modified)
f_['starred'] = f.starred
f_['file_size'] = filesizeformat(f.file_size)
f_['obj_id'] = f.obj_id
f_['perm'] = f.permission # perm for file in current dir
if not repo.encrypted and ENABLE_THUMBNAIL:
# used for providing a way to determine
# if send a request to create thumbnail.
fileExt = os.path.splitext(f.obj_name)[1][1:].lower()
file_type = FILEEXT_TYPE_MAP.get(fileExt)
if file_type == IMAGE:
f_['is_img'] = True
if file_type == VIDEO and ENABLE_VIDEO_THUMBNAIL:
f_['is_video'] = True
if file_type == XMIND:
f_['is_xmind'] = True
if file_type in (IMAGE, XMIND) or \
file_type == VIDEO and ENABLE_VIDEO_THUMBNAIL:
# if thumbnail has already been created, return its src.
# Then web browser will use this src to get thumbnail instead of
# recreating it.
thumbnail_file_path = os.path.join(THUMBNAIL_ROOT, str(size),
f.obj_id)
thumbnail_exist = os.path.exists(thumbnail_file_path)
if thumbnail_exist:
file_path = posixpath.join(path, f.obj_name)
src = get_thumbnail_src(repo_id, size, file_path)
f_['encoded_thumbnail_src'] = urlquote(src)
if is_pro_version():
f_['is_locked'] = True if f.is_locked else False
f_['lock_owner'] = f.lock_owner
f_['lock_owner_name'] = email2nickname(f.lock_owner)
f_['locked_by_me'] = False
if f.lock_owner == username:
f_['locked_by_me'] = True
if f.lock_owner == ONLINE_OFFICE_LOCK_OWNER and \
user_perm == PERMISSION_READ_WRITE:
f_['locked_by_me'] = True
dirent_list.append(f_)
result["dirent_list"] = dirent_list
return HttpResponse(json.dumps(result), content_type=content_type)
def get(self, request):
""" List all groups.
"""
org_id = None
username = request.user.username
if is_org_context(request):
org_id = request.user.org.org_id
user_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
user_groups = ccnet_api.get_groups(username, return_ancestors=True)
try:
avatar_size = int(request.GET.get('avatar_size', GROUP_AVATAR_DEFAULT_SIZE))
except ValueError:
avatar_size = GROUP_AVATAR_DEFAULT_SIZE
try:
with_repos = int(request.GET.get('with_repos', 0))
except ValueError:
with_repos = 0
if with_repos not in (0, 1):
error_msg = 'with_repos invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
groups = []
if with_repos:
gids = [g.id for g in user_groups]
admin_info = ExtraGroupsSharePermission.objects.batch_get_repos_with_admin_permission(gids)
try:
starred_repos = UserStarredFiles.objects.get_starred_repos_by_user(username)
starred_repo_id_list = [item.repo_id for item in starred_repos]
except Exception as e:
logger.error(e)
starred_repo_id_list = []
for g in user_groups:
group_info = get_group_info(request, g.id, avatar_size)
if with_repos:
if org_id:
group_repos = seafile_api.get_org_group_repos(org_id, g.id)
else:
group_repos = seafile_api.get_repos_by_group(g.id)
repos = []
# get repo id owner dict
all_repo_owner = []
repo_id_owner_dict = {}
for repo in group_repos:
repo_id = 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
# Use dict to reduce memcache fetch cost in large for-loop.
name_dict = {}
contact_email_dict = {}
for email in all_repo_owner:
if email not in name_dict:
if '@seafile_group' in email:
group_id = get_group_id_by_repo_owner(email)
group_name= group_id_to_name(group_id)
name_dict[email] = group_name
else:
name_dict[email] = email2nickname(email)
if email not in contact_email_dict:
if '@seafile_group' in email:
contact_email_dict[email] = ''
else:
contact_email_dict[email] = email2contact_email(email)
for r in group_repos:
repo_owner = repo_id_owner_dict.get(r.id, r.user)
repo = {
"id": r.id,
"repo_id": r.id,
"name": r.name,
"repo_name": r.name,
"size": r.size,
"size_formatted": filesizeformat(r.size),
"mtime": r.last_modified,
"mtime_relative": translate_seahub_time(r.last_modified),
"last_modified": timestamp_to_isoformat_timestr(r.last_modified),
"encrypted": r.encrypted,
"permission": r.permission,
"owner": repo_owner,
"owner_email": repo_owner,
"owner_name": name_dict.get(repo_owner, ''),
"owner_contact_email": contact_email_dict.get(repo_owner, ''),
"is_admin": (r.id, g.id) in admin_info,
"starred": r.repo_id in starred_repo_id_list,
}
repos.append(repo)
group_info['repos'] = repos
groups.append(group_info)
return Response(groups)
def get(self, request):
""" List all groups.
"""
org_id = None
username = request.user.username
if is_org_context(request):
org_id = request.user.org.org_id
user_groups = seaserv.get_org_groups_by_user(org_id, username)
else:
user_groups = seaserv.get_personal_groups_by_user(username)
try:
size = int(request.GET.get('avatar_size', GROUP_AVATAR_DEFAULT_SIZE))
except ValueError:
size = GROUP_AVATAR_DEFAULT_SIZE
with_repos = request.GET.get('with_repos')
with_repos = True if with_repos == '1' else False
groups = []
for g in user_groups:
try:
avatar_url, is_default, date_uploaded = api_grp_avatar_url(g.id, size)
except Exception as e:
logger.error(e)
avatar_url = get_default_group_avatar_url()
val = utc_to_local(dt(g.timestamp))
group = {
"id": g.id,
"name": g.group_name,
"creator": g.creator_name,
"created_at": val.strftime("%Y-%m-%dT%H:%M:%S") + DateFormat(val).format('O'),
"avatar_url": request.build_absolute_uri(avatar_url),
"admins": self._get_group_admins(g.id),
}
if with_repos:
if org_id:
group_repos = seafile_api.get_org_group_repos(org_id, g.id)
else:
group_repos = seafile_api.get_repos_by_group(g.id)
repos = []
for r in group_repos:
repo = {
"id": r.id,
"name": r.name,
"desc": r.desc,
"size": r.size,
"size_formatted": filesizeformat(r.size),
"mtime": r.last_modified,
"mtime_relative": translate_seahub_time(r.last_modified),
"encrypted": r.encrypted,
"permission": r.permission,
"owner": r.user,
"owner_nickname": email2nickname(r.user),
"share_from_me": True if username == r.user else False,
}
repos.append(repo)
group['repos'] = repos
groups.append(group)
return Response(groups)
