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_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)
result['last_modified'] = timestamp_to_isoformat_timestr(
repo.last_modified)
if '@seafile_group' in owner:
group_id = get_group_id_by_repo_owner(owner)
result['group_name'] = group_id_to_name(group_id)
result['owner_name'] = group_id_to_name(group_id)
else:
result['owner_name'] = email2nickname(owner)
return result
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
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, dataset_id):
"""
list accessible groups
"""
try:
dataset = DTableCommonDataset.objects.get(pk=dataset_id)
except DTableCommonDataset.DoesNotExist:
error_msg = 'dataset %s not found.' % dataset_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
# resource check
dtable = DTables.objects.filter(uuid=dataset.dtable_uuid).first()
if not dtable:
error_msg = 'DTable not found.'
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
workspace = Workspaces.objects.get_workspace_by_id(dtable.workspace_id)
if not workspace:
error_msg = 'Workspace %s not found.' % dtable.workspace_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
# permission check
if not dataset.can_manage_by_user(request.user.username, dtable):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
accessible_group_id_list = DTableCommonDatasetGroupAccess.objects.get_related_groups_id(
dataset=dataset)
accessible_group_list = [{
'group_id': group_id,
'group_name': group_id_to_name(group_id)
} for group_id in accessible_group_id_list]
return Response({'accessible_group_list': accessible_group_list})
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
if '@seafile_group' in owner:
group_id = get_group_id_by_repo_owner(repo_owner)
result['group_name'] = group_id_to_name(group_id)
return result
def _get_dtable_group_share_info(dtable_group_share):
group_id = dtable_group_share.group_id
return {
'group_id': group_id,
'group_name': group_id_to_name(group_id),
'permission': dtable_group_share.permission
}
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_trash_repo_info(repo):
result = {}
owner = repo.owner_id
result['name'] = repo.repo_name
result['id'] = repo.repo_id
result['owner'] = owner
result['delete_time'] = timestamp_to_isoformat_timestr(repo.del_time)
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_trash_repo_info(repo):
result = {}
owner = repo.owner_id
result['name'] = repo.repo_name
result['id'] = repo.repo_id
result['owner'] = owner
result['owner_name'] = email2nickname(owner)
result['delete_time'] = timestamp_to_isoformat_timestr(repo.del_time)
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):
"""get shared forms
"""
username = request.user.username
org_id = -1
if is_org_context(request):
org_id = request.user.org.org_id
if org_id and org_id > 0:
groups = ccnet_api.get_org_groups_by_user(org_id, username)
else:
groups = ccnet_api.get_groups(username, return_ancestors=True)
group_ids = [group.id for group in groups]
group_name_map = {
group_id: group_id_to_name(group_id)
for group_id in group_ids
}
try:
shared_queryset = DTableFormShare.objects.list_by_group_ids(
group_ids)
except Exception as e:
logger.error(e)
error_msg = 'Internal Server Error.'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
shared_list = list()
for item in shared_queryset:
form = item.form
if form.share_type != SHARED_GROUPS:
continue
data = form.to_dict()
group_id = item.group_id
data["group_name"] = group_name_map.get(group_id)
data["group_id"] = group_id
shared_list.append(data)
return Response({'shared_list': shared_list},
status=status.HTTP_200_OK)
def get_group_repo_info(repo):
result = {}
result['repo_id'] = repo.repo_id
result['name'] = repo.repo_name
result['size'] = repo.size
result['shared_by'] = repo.user
if '@seafile_group' in repo.user:
group_id = get_group_id_by_repo_owner(repo.user)
group_name = group_id_to_name(group_id)
result['shared_by_name'] = group_name
else:
result['shared_by_name'] = email2nickname(repo.user)
result['permission'] = repo.permission
result['group_id'] = repo.group_id
result['encrypted'] = repo.encrypted
return result
def get(self, request):
"""list dtables from shared
"""
to_user = request.user.username
try:
share_queryset = DTableShare.objects.list_by_to_user(to_user)
except Exception as e:
logger.error(e)
error_msg = 'Internal Server Error.'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
table_list = list()
for item in share_queryset:
from_user = item.from_user
permission = item.permission
dtable = item.dtable
dtable_info = dict()
dtable_info['id'] = dtable.pk
dtable_info['workspace_id'] = dtable.workspace_id
dtable_info['uuid'] = dtable.uuid
dtable_info['name'] = dtable.name
dtable_info['creator'] = email2nickname(dtable.creator)
dtable_info['modifier'] = email2nickname(dtable.modifier)
dtable_info['created_at'] = datetime_to_isoformat_timestr(
dtable.created_at)
dtable_info['updated_at'] = datetime_to_isoformat_timestr(
dtable.updated_at)
dtable_info['permission'] = permission
dtable_info['from_user'] = from_user
if '@seafile_group' in from_user:
group_id = from_user.split('@')[0]
dtable_info['from_user_name'] = group_id_to_name(group_id)
else:
dtable_info['from_user_name'] = email2nickname(from_user)
table_list.append(dtable_info)
return Response({'table_list': table_list})
def get(self, request):
"""get dtable forms
Permission:
1. owner
2. group member
3. shared user with `rw`
"""
username = request.user.username
# argument check
workspace_id = request.GET.get('workspace_id')
table_name = request.GET.get('name')
# get user forms
if not workspace_id and not table_name:
org_id = -1
if is_org_context(request):
org_id = request.user.org.org_id
if org_id and org_id > 0:
groups = ccnet_api.get_org_groups_by_user(org_id, username)
else:
groups = ccnet_api.get_groups(username, return_ancestors=True)
owner_list = list()
owner_list.append(username)
for group in groups:
group_user = '******' % group.id
owner_list.append(group_user)
try:
# workspaces
workspace_queryset = Workspaces.objects.filter(
owner__in=owner_list)
workspace_ids = [
workspace.id for workspace in workspace_queryset
]
form_queryset = DTableForms.objects.filter(
workspace_id__in=workspace_ids)
except Exception as e:
logger.error(e)
error_msg = 'Internal Server Error.'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR,
error_msg)
# forms
group_name_map = {
group.id: group_id_to_name(group.id)
for group in groups
}
form_list = list()
for form in form_queryset:
data = form.to_dict()
workspace_id = form.workspace_id
workspace = workspace_queryset.get(id=workspace_id)
owner = workspace.owner
if '@seafile_group' in owner:
group_id = int(owner.split('@')[0])
data["group_name"] = group_name_map.get(group_id)
data["group_id"] = group_id
form_list.append(data)
return Response({"form_list": form_list},
status=status.HTTP_200_OK)
# get dtable forms
else:
if not workspace_id:
error_msg = 'workspace_id invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
if not table_name:
error_msg = 'name invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
# resource check
workspace, dtable, error_msg = _resource_check(
workspace_id, table_name)
if error_msg:
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
# permission check
if check_dtable_permission(username, workspace,
dtable) != PERMISSION_READ_WRITE:
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
dtable_uuid = dtable.uuid.hex
try:
forms = DTableForms.objects.get_forms_by_dtable_uuid(
dtable_uuid)
except Exception as e:
logger.error(e)
error_msg = 'Internal Server Error'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR,
error_msg)
form_list = [form_obj.to_dict() for form_obj in forms]
return Response({"form_list": form_list},
status=status.HTTP_200_OK)
def get(self, request, group_id):
""" Get all group libraries.
Permission checking:
1. is group member;
"""
# only group member can get group libraries
username = request.user.username
if not is_group_member(group_id, request.user.username):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
if is_org_context(request):
org_id = request.user.org.org_id
group_repos = seafile_api.get_org_group_repos(org_id, group_id)
else:
group_repos = seafile_api.get_repos_by_group(group_id)
group_repos.sort(key=lambda x: x.last_modified, reverse=True)
try:
current_page = int(request.GET.get('page', '1'))
per_page = int(request.GET.get('per_page', '100'))
except ValueError:
current_page = 1
per_page = 100
start = (current_page - 1) * per_page
group_repos = group_repos[start:start + per_page]
# 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
all_modifier = [r.last_modifier for r in group_repos]
# Use dict to reduce memcache fetch cost in large for-loop.
name_dict = {}
contact_email_dict = {}
for email in set(all_repo_owner + all_modifier):
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)
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 = []
result = []
for group_repo in group_repos:
group_repo_info = get_group_repo_info(request, group_repo)
repo_owner = repo_id_owner_dict[group_repo.id]
group_repo_info['owner_email'] = repo_owner
group_repo_info['owner_name'] = name_dict.get(repo_owner, '')
group_repo_info['owner_contact_email'] = contact_email_dict.get(
repo_owner, '')
modifier = group_repo.last_modifier
group_repo_info['modifier_email'] = modifier
group_repo_info['modifier_name'] = name_dict.get(modifier, '')
group_repo_info['modifier_contact_email'] = contact_email_dict.get(
modifier, '')
group_repo_info['starred'] = group_repo.id in starred_repo_id_list
result.append(group_repo_info)
return Response(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})
def org_repo_search(request):
"""Search an organization repo.
"""
repo_name = request.GET.get('name', '')
owner = request.GET.get('owner', '')
org_id = request.user.org.org_id
repos = []
if repo_name and owner: # search by name and owner
repos = list_org_repos_by_name_and_owner(org_id, repo_name, owner)
for repo in repos:
repo.owner_name = email2nickname(owner)
repo.is_department_repo = False
repo.group_id = ''
elif repo_name: # search by name
repos = list_org_repos_by_name(org_id, repo_name)
# get repo id owner dict
all_repo_owner = []
repo_id_owner_dict = {}
for repo in repos:
repo_owner = seafile_api.get_org_repo_owner(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 = {}
for email in set(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)
for repo in repos:
repo_owner = repo_id_owner_dict[repo.id]
repo.owner = repo_owner
repo.owner_name = name_dict.get(repo.owner, '')
if '@seafile_group' in repo_owner:
repo.is_department_repo = True
group_id = get_group_id_by_repo_owner(repo_owner)
repo.group_id = group_id
else:
repo.is_department_repo = False
repo.group_id = ''
elif owner: # search by owner
repos = list_org_repos_by_owner(org_id, owner)
for repo in repos:
repo.owner_name = email2nickname(owner)
repo.is_department_repo = False
repo.group_id = ''
return render(request, 'organizations/org_repo_search.html', {
'repos': repos,
'name': repo_name,
'owner': owner,
})
def get(self, request, group_id):
""" Get all group libraries.
Permission checking:
1. is group member;
"""
# only group member can get group libraries
username = request.user.username
if not is_group_member(group_id, request.user.username):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
if is_org_context(request):
org_id = request.user.org.org_id
group_repos = seafile_api.get_org_group_repos(org_id, group_id)
else:
group_repos = seafile_api.get_repos_by_group(group_id)
group_repos.sort(lambda x, y: cmp(y.last_modified, x.last_modified))
# 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
all_modifier = [r.last_modifier for r in group_repos]
# Use dict to reduce memcache fetch cost in large for-loop.
name_dict = {}
contact_email_dict = {}
for email in set(all_repo_owner + all_modifier):
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)
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 = []
result = []
for group_repo in group_repos:
group_repo_info = get_group_repo_info(request, group_repo)
repo_owner = repo_id_owner_dict[group_repo.id]
group_repo_info['owner_email'] = repo_owner
group_repo_info['owner_name'] = name_dict.get(repo_owner, '')
group_repo_info['owner_contact_email'] = contact_email_dict.get(repo_owner, '')
modifier = group_repo.last_modifier
group_repo_info['modifier_email'] = modifier
group_repo_info['modifier_name'] = name_dict.get(modifier, '')
group_repo_info['modifier_contact_email'] = contact_email_dict.get(modifier, '')
group_repo_info['starred'] = group_repo.id in starred_repo_id_list
result.append(group_repo_info)
return Response(result)
def get(self, request, org_id):
"""List organization libraries
"""
# 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)
# Make sure page request is an int. If not, deliver first page.
try:
current_page = int(request.GET.get('page', '1'))
per_page = int(request.GET.get('per_page', '25'))
except ValueError:
current_page = 1
per_page = 25
repos_all = seafile_api.get_org_repo_list(
org_id, per_page * (current_page - 1), per_page + 1)
page_next = False
if len(repos_all) == per_page + 1:
page_next = True
repos = repos_all[:per_page]
repos = filter(lambda r: not r.is_virtual, repos)
# get repo id owner dict
all_repo_owner = []
repo_id_owner_dict = {}
for repo in repos:
if repo.id not in repo_id_owner_dict:
repo_owner = seafile_api.get_org_repo_owner(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.
repo_owner_dict = {}
for email in set(all_repo_owner):
if email not in repo_owner_dict:
repo_owner_dict[email] = {}
if '@seafile_group' in email:
group_id = get_group_id_by_repo_owner(email)
group_name = group_id_to_name(group_id)
repo_owner_dict[email]['owner_name'] = group_name
repo_owner_dict[email]['group_id'] = group_id
repo_owner_dict[email]['is_department_repo'] = True
else:
repo_owner_dict[email]['owner_name'] = email2nickname(
email)
repo_owner_dict[email]['group_id'] = ''
repo_owner_dict[email]['is_department_repo'] = False
repo_list = []
for r in repos:
repo = {}
repo_owner = repo_id_owner_dict[r.id]
repo['owner_email'] = repo_owner
repo['owner_name'] = repo_owner_dict[repo_owner]['owner_name']
repo['encrypted'] = r.encrypted
repo['repo_id'] = r.id
repo['repo_name'] = r.name
repo['is_department_repo'] = repo_owner_dict[repo_owner][
'is_department_repo']
repo['group_id'] = repo_owner_dict[repo_owner]['group_id']
repo_list.append(repo)
return Response({
'repo_list': repo_list,
'page': current_page,
'page_next': page_next,
})
def post(self, request, dataset_id):
"""
add accessible groups
"""
try:
dataset = DTableCommonDataset.objects.get(pk=dataset_id)
except DTableCommonDataset.DoesNotExist:
error_msg = 'dataset %s not found.' % dataset_id
return api_error(status.HTTP_404_NOT_FOUND, error_msg)
group_id_list = request.data.getlist('group_id', '')
if not group_id_list:
error_msg = 'group_id invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
try:
group_id_list = [int(group_id) for group_id in group_id_list]
except Exception as e:
logging.error(e)
error_msg = 'group_id invalid.'
return api_error(status.HTTP_400_BAD_REQUEST, error_msg)
success_res_list = []
failed_res_list = []
for group_id in group_id_list:
group = ccnet_api.get_group(group_id)
if not group:
error_msg = 'group %s not found.' % group_id
failed_res_list.append({
'failed_group_id': group_id,
'error_msg': error_msg
})
continue
# resource check
dtable = DTables.objects.filter(uuid=dataset.dtable_uuid).first()
if not dtable:
error_msg = 'DTable not found.'
failed_res_list.append({
'failed_group_id': group_id,
'error_msg': error_msg
})
continue
workspace = Workspaces.objects.get_workspace_by_id(
dtable.workspace_id)
if not workspace:
error_msg = 'Workspace %s not found.' % dtable.workspace_id
failed_res_list.append({
'failed_group_id': group_id,
'error_msg': error_msg
})
continue
# permission check
if not dataset.can_manage_by_user(request.user.username, dtable):
error_msg = 'Permission denied.'
failed_res_list.append({
'failed_group_id': group_id,
'error_msg': error_msg
})
continue
try:
DTableCommonDatasetGroupAccess.objects.get(dataset=dataset,
group_id=group_id)
error_msg = _(
'group %s accessible to dataset %s already exists.') % (
group_id, dataset.dataset_name)
failed_res_list.append({
'failed_group_id': group_id,
'error_msg': error_msg
})
continue
except DTableCommonDatasetGroupAccess.DoesNotExist:
pass
DTableCommonDatasetGroupAccess.objects.create(
dataset=dataset,
group_id=group_id,
)
success_res_list.append({
'group_id': group_id,
'group_name': group_id_to_name(group_id)
})
return Response({
'success_list': success_res_list,
'failed_list': failed_res_list
})
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
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
}
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,
}
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,
}
repo_info_list.append(repo_info)
if filter_by['public'] and request.user.permissions.can_view_org():
public_repos = list_inner_pub_repos(request)
# Reduce memcache fetch ops.
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:
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_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, ''),
"size": r.size,
"encrypted": r.encrypted,
"permission": r.permission,
}
repo_info_list.append(repo_info)
return Response({'repos': repo_info_list})
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,
}
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,
}
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,
}
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,
}
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})
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 org_repo_admin(request):
"""Show organization libraries.
"""
org_id = request.user.org.org_id
# Make sure page request is an int. If not, deliver first page.
try:
current_page = int(request.GET.get('page', '1'))
per_page = int(request.GET.get('per_page', '25'))
except ValueError:
current_page = 1
per_page = 25
repos_all = seafile_api.get_org_repo_list(org_id,
per_page * (current_page - 1),
per_page + 1)
repos = repos_all[:per_page]
if len(repos_all) == per_page + 1:
page_next = True
else:
page_next = False
repos = filter(lambda r: not r.is_virtual, repos)
# get repo id owner dict
all_repo_owner = []
repo_id_owner_dict = {}
for repo in repos:
repo_owner = seafile_api.get_org_repo_owner(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 = {}
for email in set(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)
for repo in repos:
repo_owner = repo_id_owner_dict[repo.id]
repo.owner = repo_owner
repo.owner_name = name_dict.get(repo.owner, '')
if '@seafile_group' in repo_owner:
repo.is_department_repo = True
group_id = get_group_id_by_repo_owner(repo_owner)
repo.group_id = group_id
else:
repo.is_department_repo = False
repo.group_id = ''
return render(
request, 'organizations/org_repo_admin.html', {
'repos': repos,
'current_page': current_page,
'prev_page': current_page - 1,
'next_page': current_page + 1,
'per_page': per_page,
'page_next': page_next,
})
def get(self, request, group_id):
""" Get all group libraries.
Permission checking:
1. is group member;
"""
# only group member can get group libraries
if not is_group_member(group_id, request.user.username):
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
if is_org_context(request):
org_id = request.user.org.org_id
group_repos = seafile_api.get_org_group_repos(org_id, group_id)
else:
group_repos = seafile_api.get_repos_by_group(group_id)
group_repos.sort(lambda x, y: cmp(y.last_modified, x.last_modified))
# 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
all_modifier = [r.last_modifier for r in group_repos]
# Use dict to reduce memcache fetch cost in large for-loop.
name_dict = {}
contact_email_dict = {}
for email in set(all_repo_owner + all_modifier):
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)
result = []
for group_repo in group_repos:
group_repo_info = get_group_repo_info(request, group_repo)
repo_owner = repo_id_owner_dict[group_repo.id]
group_repo_info['owner_email'] = repo_owner
group_repo_info['owner_name'] = name_dict.get(repo_owner, '')
group_repo_info['owner_contact_email'] = contact_email_dict.get(
repo_owner, '')
modifier = group_repo.last_modifier
group_repo_info['modifier_email'] = modifier
group_repo_info['modifier_name'] = name_dict.get(modifier, '')
group_repo_info['modifier_contact_email'] = contact_email_dict.get(
modifier, '')
result.append(group_repo_info)
return Response(result)
def get(self, request):
"""get all workspaces
"""
username = request.user.username
org_id = -1
if is_org_context(request):
org_id = request.user.org.org_id
if org_id and org_id > 0:
groups = ccnet_api.get_org_groups_by_user(org_id, username)
else:
groups = ccnet_api.get_groups(username, return_ancestors=True)
owner_list = list()
owner_list.append(username)
for group in groups:
group_user = '******' % group.id
owner_list.append(group_user)
try:
# workspaces
workspace_queryset = Workspaces.objects.filter(
owner__in=owner_list)
workspaces = list(workspace_queryset)
# user workspace
if not workspace_queryset.filter(owner=username).exists():
workspace = create_repo_and_workspace(username, org_id)
workspaces.append(workspace)
# dtables
table_queryset = DTables.objects.filter(workspace__in=workspaces,
deleted=False)
except Exception as e:
logger.error(e)
error_msg = 'Internal Server Error.'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg)
try:
starred_dtable_uuids = set(
UserStarredDTables.objects.get_dtable_uuids_by_email(username))
except Exception as e:
starred_dtable_uuids = set()
logger.warning(e)
workspace_list = list()
for workspace in workspaces:
# resource check
repo_id = workspace.repo_id
repo = seafile_api.get_repo(repo_id)
if not repo:
logger.warning('Library %s not found.' % repo_id)
continue
res = workspace.to_dict()
tables = table_queryset.filter(workspace=workspace)
res["table_list"] = [table.to_dict() for table in tables]
for t in res['table_list']:
t['starred'] = t['uuid'].hex in starred_dtable_uuids
owner = workspace.owner
if '@seafile_group' in owner:
group_id = owner.split('@')[0]
group_members = ccnet_api.get_group_members(int(group_id))
group_admins = [
m.user_name for m in group_members if m.is_staff
]
group_owner = [
g.creator_name for g in groups if g.id == int(group_id)
][0]
res["owner_name"] = group_id_to_name(group_id)
res["owner_type"] = "Group"
res["group_id"] = group_id
res["group_owner"] = group_owner
res["group_admins"] = group_admins
else:
res["owner_name"] = email2nickname(owner)
res["owner_type"] = "Personal"
workspace_list.append(res)
if DTABLE_EVENTS_ENABLED:
timestamp = datetime.utcnow().strftime('%Y-%m-%d 00:00:00')
message = {
'username': username,
'timestamp': timestamp,
'org_id': org_id
}
try:
events_redis_connection.publish('user-activity-statistic',
json.dumps(message))
except Exception as e:
logger.error("Failed to publish message: %s " % e)
return Response({"workspace_list": workspace_list},
status=status.HTTP_200_OK)
def get(self, request):
"""get all workspaces
"""
username = request.user.username
org_id = -1
if is_org_context(request):
org_id = request.user.org.org_id
if org_id > 0:
groups = ccnet_api.get_org_groups_by_user(org_id, username)
else:
groups = ccnet_api.get_groups(username, return_ancestors=True)
owner_list = list()
owner_list.append(username)
for group in groups:
group_user = '******' % group.id
owner_list.append(group_user)
workspace_list = list()
for owner in owner_list:
try:
workspace = Workspaces.objects.get_workspace_by_owner(owner)
except Exception as e:
logger.error(e)
error_msg = 'Internal Server Error.'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR,
error_msg)
if not workspace:
if '@seafile_group' in owner:
continue
# permission check
if not request.user.permissions.can_add_repo():
error_msg = 'Permission denied.'
return api_error(status.HTTP_403_FORBIDDEN, error_msg)
try:
if org_id > 0:
repo_id = seafile_api.create_org_repo(
_("My Workspace"), _("My Workspace"),
"dtable@seafile", org_id)
else:
repo_id = seafile_api.create_repo(
_("My Workspace"), _("My Workspace"),
"dtable@seafile")
except Exception as e:
logger.error(e)
error_msg = 'Internal Server Error.'
return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR,
error_msg)
workspace = Workspaces.objects.create_workspace(owner, repo_id)
# resource check
repo_id = workspace.repo_id
repo = seafile_api.get_repo(repo_id)
if not repo:
logger.warning('Library %s not found.' % repo_id)
continue
res = workspace.to_dict()
table_list = DTables.objects.get_dtable_by_workspace(workspace)
res["table_list"] = table_list
if '@seafile_group' in owner:
group_id = owner.split('@')[0]
res["owner_name"] = group_id_to_name(group_id)
res["owner_type"] = "Group"
else:
res["owner_name"] = email2nickname(owner)
res["owner_type"] = "Personal"
workspace_list.append(res)
return Response({"workspace_list": workspace_list},
status=status.HTTP_200_OK)
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 = 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 dtable_form_edit(request, token):
"""
Permission:
1. owner
2. group member
3. shared user with `rw` permission
"""
# resource check
form_obj = DTableForms.objects.get_form_by_token(token)
if not form_obj:
return render_error(request, 'Table\'s form does not exist.')
workspace_id = form_obj.workspace_id
workspace = Workspaces.objects.get_workspace_by_id(workspace_id)
if not workspace:
return render_error(request, 'Workspace does not exist.')
dtable_uuid = form_obj.dtable_uuid
dtable = DTables.objects.get_dtable_by_uuid(dtable_uuid)
if not dtable:
return render_error(request, 'Table does not exist.')
# permission check
username = request.user.username
permission = check_dtable_permission(username, workspace, dtable)
if permission != PERMISSION_READ_WRITE:
return render_permission_error(request, 'Permission denied.')
if not check_user_workspace_quota(workspace):
return render_error(request, 'Asset quota exceeded.')
# generate json web token
payload = {
'exp': int(time.time()) + 60 * 5,
'dtable_uuid': dtable_uuid,
'username': "******",
'permission': permission,
}
try:
access_token = jwt.encode(payload,
DTABLE_PRIVATE_KEY,
algorithm='HS256')
except Exception as e:
logger.error(e)
return render_error(request, _('Internal Server Error'))
url = '%s/api/v1/dtables/%s/metadata/' % (DTABLE_SERVER_URL.strip('/'),
dtable_uuid)
req = requests.Request(
url, headers={"Authorization": "Token %s" % access_token.decode()})
try:
dtable_metadata = requests.urlopen(req).read().decode()
except Exception as e:
logger.error(e)
return render_error(request, _('Internal Server Error'))
share_type = form_obj.share_type
shared_groups = list()
if share_type == SHARED_GROUPS:
group_ids = DTableFormShare.objects.list_by_form(form_obj)
shared_groups = [{
'id': group_id,
'name': group_id_to_name(group_id)
} for group_id in group_ids]
return_dict = {
'dtable_metadata': dtable_metadata,
'dtable_name': dtable.name,
'workspace_id': workspace_id,
'form_id': form_obj.form_id,
'form_config': form_obj.form_config,
'dtable_uuid': dtable.uuid.hex,
'dtable_web_service_url': DTABLE_WEB_SERVICE_URL,
'form_token': token,
'share_type': share_type,
'shared_groups': json.dumps(shared_groups),
}
return render(request, 'dtable_edit_form_view_react.html', return_dict)
