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)