def avatar(user, size=AVATAR_DEFAULT_SIZE): if not isinstance(user, User): try: user = User.objects.get(email=user) alt = email2nickname(user.username) url = avatar_url(user, size) except User.DoesNotExist: url = get_default_avatar_non_registered_url() alt = _("Default Avatar") except Exception as e: # Catch exceptions to avoid 500 errors. logger.error(e) url = get_default_avatar_non_registered_url() alt = _("Default Avatar") else: alt = email2nickname(user.username) try: url = avatar_url(user, size) except Exception as e: # Catch exceptions to avoid 500 errors. logger.error(e) url = get_default_avatar_non_registered_url() return """<img src="%s" alt="%s" width="%s" height="%s" class="avatar" />""" % (url, alt, size, size)
def test_can_edit(self): assert email2nickname(self.tmp_user.username) == self.tmp_user.username.split('@')[0] resp = self.client.post(self.url, { 'nickname': 'new nickname' }) self.assertEqual(302, resp.status_code) self.assertRegexpMatches(resp['Location'], r'http://testserver/profile/') assert email2nickname(self.tmp_user.username) == 'new nickname'
def test_refresh_profile_cache_after_update(self): self.login_as(self.admin) self.assertEqual(email2nickname(self.user1.username), self.user1.username.split('@')[0]) resp = self._do_update() self.assertEqual(200, resp.status_code) self.assertEqual(email2nickname(self.user1.username), 'user1')
def test_updated_when_call_save(self): username = self.tmp_user.username assert email2nickname(username) == username.split('@')[0] p = Profile.objects.get_profile_by_user(username) if p is None: p = Profile(user=username) p.nickname = 'nickname' p.save() assert email2nickname(username) == 'nickname'
def list_user_shared_items(self, request, repo_id, path): username = request.user.username if is_org_context(request): org_id = request.user.org.org_id if path == '/': share_items = seafile_api.list_org_repo_shared_to(org_id, username, repo_id) else: share_items = seafile_api.get_org_shared_users_for_subdir(org_id, repo_id, path, username) else: if path == '/': share_items = seafile_api.list_repo_shared_to(username, repo_id) else: share_items = seafile_api.get_shared_users_for_subdir(repo_id, path, username) ret = [] for item in share_items: ret.append({ "share_type": "user", "user_info": { "name": item.user, "nickname": email2nickname(item.user), }, "permission": item.perm, }) return ret
def get_group_member_info(request, group_id, email, avatar_size=AVATAR_DEFAULT_SIZE): p = Profile.objects.get_profile_by_user(email) if p: login_id = p.login_id if p.login_id else '' else: login_id = '' try: avatar_url, is_default, date_uploaded = api_avatar_url(email, avatar_size) except Exception as e: logger.error(e) avatar_url = get_default_avatar_url() role = 'Member' group = ccnet_api.get_group(int(group_id)) is_admin = bool(ccnet_api.check_group_staff(int(group_id), email)) if email == group.creator_name: role = 'Owner' elif is_admin: role = 'Admin' member_info = { 'group_id': group_id, "name": email2nickname(email), 'email': email, "contact_email": Profile.objects.get_contact_email_by_user(email), "login_id": login_id, "avatar_url": request.build_absolute_uri(avatar_url), "is_admin": is_admin, "role": role, } return member_info
def format_group_message_title(self): """ Arguments: - `self`: """ try: d = self.group_message_detail_to_dict() except self.InvalidDetailError as e: logger.error(e) return _(u"Internal error") group_id = d.get('group_id') group = ccnet_api.get_group(group_id) if group is None: self.delete() return None msg_from = d.get('msg_from') if msg_from is None: msg = _(u"<a href='%(href)s'>%(group_name)s</a> has a new discussion.") % { 'href': HASH_URLS['GROUP_DISCUSS'] % {'group_id': group.id}, 'group_name': group.group_name} else: msg = _(u"%(user)s posted a new discussion in <a href='%(href)s'>%(group_name)s</a>.") % { 'href': HASH_URLS['GROUP_DISCUSS'] % {'group_id': group.id}, 'user': escape(email2nickname(msg_from)), 'group_name': escape(group.group_name) } return msg
def format_add_user_to_group(self): """ Arguments: - `self`: """ try: d = json.loads(self.detail) except Exception as e: logger.error(e) return _(u"Internal error") group_staff = d['group_staff'] group_id = d['group_id'] group = ccnet_api.get_group(group_id) if group is None: self.delete() return None msg = _(u"User <a href='%(user_profile)s'>%(group_staff)s</a> has added you to group <a href='%(href)s'>%(group_name)s</a>") % { 'user_profile': reverse('user_profile', args=[group_staff]), 'group_staff': escape(email2nickname(group_staff)), 'href': reverse('group', args=[group_id]), 'group_name': escape(group.group_name)} return msg
def _get_address_book_group_memeber_info(self, request, group_member_obj, avatar_size): email = group_member_obj.user_name try: avatar_url, is_default, date_uploaded = api_avatar_url(email, avatar_size) except Exception as e: logger.error(e) avatar_url = get_default_avatar_url() group_id = group_member_obj.group_id group = ccnet_api.get_group(group_member_obj.group_id) role = 'Member' is_admin = bool(group_member_obj.is_staff) if email == group.creator_name: role = 'Owner' elif is_admin: role = 'Admin' member_info = { 'group_id': group_id, 'group_name': group.group_name, 'email': email, "name": email2nickname(email), "contact_email": email2contact_email(email), "avatar_url": request.build_absolute_uri(avatar_url), "is_admin": is_admin, "role": role, } return member_info
def format_file_comment_msg(self): try: d = json.loads(self.detail) except Exception as e: logger.error(e) return _(u"Internal error") repo_id = d['repo_id'] file_path = d['file_path'] author = d['author'] comment = d['comment'] repo = seafile_api.get_repo(repo_id) if repo is None or not seafile_api.get_file_id_by_path(repo.id, file_path): self.delete() return None file_name = os.path.basename(file_path) msg = _("File <a href='%(file_url)s'>%(file_name)s</a> has a new comment from user %(author)s") % { 'file_url': reverse('view_lib_file', args=[repo_id, file_path]), 'file_name': escape(file_name), 'author': escape(email2nickname(author)), } return msg
def get(self, request): if not is_pro_version(): error_msg = 'Feature disabled.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) # check the date format, should be like '2015-10-10' start = request.GET.get('start', None) end = request.GET.get('end', None) if not check_time_period_valid(start, end): error_msg = 'start or end date invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) # Filtering a DateTimeField with dates won't include items on the last day, # because the bounds are interpreted as '0am on the given date'. end = end + ' 23:59:59' result = [] from seahub_extra.sysadmin_extra.models import UserLoginLog logs = UserLoginLog.objects.filter(login_date__range=(start, end)) for log in logs: result.append({ 'login_time': datetime_to_isoformat_timestr(log.login_date), 'login_ip': log.login_ip, 'name': email2nickname(log.username), 'email':log.username }) return Response(result)
def user_profile(request, username): if is_valid_username(username): try: user = User.objects.get(email=username) except User.DoesNotExist: user = None else: user = None nickname = '' if user is None else email2nickname(user.username) if user is not None: profile = Profile.objects.get_profile_by_user(user.username) intro = profile.intro if profile else '' d_profile = DetailedProfile.objects.get_detailed_profile_by_user( user.username) else: intro = _(u'Has not accepted invitation yet') d_profile = None return render_to_response('profile/user_profile.html', { 'user': user, 'nickname': nickname, 'intro': intro, 'd_profile': d_profile, }, context_instance=RequestContext(request))
def format_group_message_title(self): """ Arguments: - `self`: """ try: d = self.group_message_detail_to_dict() except self.InvalidDetailError as e: return _(u"Internal error") group_id = d.get('group_id') group = seaserv.get_group(group_id) if group is None: self.delete() return None msg_from = d.get('msg_from') if msg_from is None: msg = _(u"<a href='%(href)s'>%(group_name)s</a> has a new discussion.") % { 'href': reverse('group_discuss', args=[group.id]), 'group_name': group.group_name} else: msg = _(u"%(user)s posted a new discussion in <a href='%(href)s'>%(group_name)s</a>.") % { 'href': reverse('group_discuss', args=[group.id]), 'user': escape(email2nickname(msg_from)), 'group_name': group.group_name} return msg
def format_grpmsg_reply(self, notice): d = json.loads(notice.detail) notice.group_msg_reply_url = reverse('msg_reply_new') notice.group_msg_reply_from = escape(email2nickname(d['reply_from'])) notice.group_msg_reply_from_avatar_url = self.get_avatar_url(d['reply_from']) return notice
def get(self, request, format=None): """ List all shared out folders. Permission checking: 1. all authenticated user can perform this action. """ shared_repos = [] username = request.user.username try: if is_org_context(request): org_id = request.user.org.org_id shared_repos += seafile_api.get_org_share_out_repo_list(org_id, username, -1, -1) shared_repos += seaserv.seafserv_threaded_rpc.get_org_group_repos_by_owner(org_id, username) else: shared_repos += seafile_api.get_share_out_repo_list(username, -1, -1) shared_repos += seafile_api.get_group_repos_by_owner(username) except Exception as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) returned_result = [] shared_repos.sort(lambda x, y: cmp(x.repo_name, y.repo_name)) for repo in shared_repos: if not repo.is_virtual: continue result = {} result['repo_id'] = repo.origin_repo_id result['repo_name'] = repo.origin_repo_name result['path'] = repo.origin_path result['folder_name'] = repo.name result['share_type'] = repo.share_type result['share_permission'] = repo.permission if repo.share_type == 'personal': result['user_name'] = email2nickname(repo.user) result['user_email'] = repo.user result['contact_email'] = Profile.objects.get_contact_email_by_user(repo.user) if repo.share_type == 'group': group = ccnet_api.get_group(repo.group_id) if not group: if is_org_context(request): seafile_api.org_unshare_subdir_for_group(org_id, repo.repo_id, repo.origin_path, username, repo.group_id) else: seafile_api.unshare_subdir_for_group( repo.repo_id, repo.origin_path, username, repo.group_id) continue result['group_id'] = repo.group_id result['group_name'] = group.group_name returned_result.append(result) return Response(returned_result)
def format_repo_share_msg(self, notice): d = json.loads(notice.detail) repo_id = d['repo_id'] repo = seafile_api.get_repo(repo_id) path = d['path'] org_id = d.get('org_id', None) if path == '/': shared_type = 'library' else: shared_type = 'folder' if org_id: owner = seafile_api.get_org_repo_owner(repo_id) repo = seafile_api.get_org_virtual_repo( org_id, repo_id, path, owner) else: owner = seafile_api.get_repo_owner(repo_id) repo = seafile_api.get_virtual_repo(repo_id, path, owner) repo_url = reverse('lib_view', args=[repo_id, repo.name, '']) notice.repo_url = repo_url notice.notice_from = escape(email2nickname(d['share_from'])) notice.repo_name = repo.name notice.avatar_src = self.get_avatar_src(d['share_from']) notice.shared_type = shared_type return notice
def format_group_join_request(self): """ Arguments: - `self`: """ d = json.loads(self.detail) username = d['username'] group_id = d['group_id'] join_request_msg = d['join_request_msg'] group = seaserv.get_group(group_id) if group is None: self.delete() return None nickname = email2nickname(username) msg = _(u"User <a href='%(user_profile)s'>%(username)s</a> has asked to join group <a href='%(href)s'>%(group_name)s</a>, verification message: %(join_request_msg)s") % { 'user_profile': reverse('user_profile', args=[username]), 'username': username, 'href': reverse('group_members', args=[group_id]), 'group_name': group.group_name, 'join_request_msg': join_request_msg, } return msg
def user_profile(request, username): if is_valid_username(username): try: user = User.objects.get(email=username) except User.DoesNotExist: user = None else: user = None if user is not None: nickname = email2nickname(user.username) contact_email = Profile.objects.get_contact_email_by_user(user.username) d_profile = DetailedProfile.objects.get_detailed_profile_by_user( user.username) else: nickname = '' contact_email = '' d_profile = None return render_to_response('profile/user_profile.html', { 'user': user, 'nickname': nickname, 'contact_email': contact_email, 'd_profile': d_profile, }, context_instance=RequestContext(request))
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_user_info(email): user = User.objects.get(email=email) d_profile = DetailedProfile.objects.get_detailed_profile_by_user(email) profile = Profile.objects.get_profile_by_user(email) info = {} info['email'] = email info['name'] = email2nickname(email) info['contact_email'] = profile.contact_email if profile and profile.contact_email else '' info['login_id'] = profile.login_id if profile and profile.login_id else '' info['is_staff'] = user.is_staff info['is_active'] = user.is_active info['create_time'] = user.ctime info['reference_id'] = user.reference_id if user.reference_id else '' info['department'] = d_profile.department if d_profile else '' info['quota_total'] = seafile_api.get_user_quota(email) info['quota_usage'] = seafile_api.get_user_self_usage(email) info['create_time'] = timestamp_to_isoformat_timestr(user.ctime) if is_pro_version(): info['role'] = user.role return info
def get(self, request): if not is_pro_version(): error_msg = 'Feature disabled.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) # check the date format, should be like '2015-10-10' start = request.GET.get('start', None) end = request.GET.get('end', None) if not check_time_period_valid(start, end): error_msg = 'start or end date invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) result = [] events = get_log_events_by_type_and_time('file_audit', start, end) if events: for ev in events: tmp_repo = seafile_api.get_repo(ev.repo_id) tmp_repo_name = tmp_repo.name if tmp_repo else '' result.append({ 'repo_id': ev.repo_id, 'repo_name': tmp_repo_name, 'time': datetime_to_isoformat_timestr(ev.timestamp), 'etype': ev.etype, 'ip': ev.ip, 'file_path': ev.file_path, 'etype': ev.etype, 'user_name': email2nickname(ev.user), 'user_email': ev.user }) return Response(result)
def format_repo_share_msg(self): """ Arguments: - `self`: """ try: d = json.loads(self.detail) except Exception as e: logger.error(e) return _(u"Internal error") share_from = email2nickname(d['share_from']) repo_id = d['repo_id'] repo = seafile_api.get_repo(repo_id) if repo is None: self.delete() return None msg = _(u"%(user)s has shared a library named <a href='%(href)s'>%(repo_name)s</a> to you.") % { 'user': escape(share_from), 'href': reverse('view_common_lib_dir', args=[repo.id, '']), 'repo_name': escape(repo.name), } return msg
def get(self, request): """ List all groups. """ org_id = None username = request.user.username if is_org_context(request): org_id = request.user.org.org_id user_groups = seaserv.get_org_groups_by_user(org_id, username) else: user_groups = seaserv.get_personal_groups_by_user(username) try: size = int(request.GET.get('avatar_size', GROUP_AVATAR_DEFAULT_SIZE)) except ValueError: size = GROUP_AVATAR_DEFAULT_SIZE try: with_repos = int(request.GET.get('with_repos', 0)) except ValueError: with_repos = 0 if with_repos not in (0, 1): error_msg = _(u'Argument can only be 0 or 1') return api_error(status.HTTP_400_BAD_REQUEST, error_msg) groups = [] for g in user_groups: group_info = get_group_info(request, g.id , size) if with_repos: if org_id: group_repos = seafile_api.get_org_group_repos(org_id, g.id) else: group_repos = seafile_api.get_repos_by_group(g.id) repos = [] for r in group_repos: repo = { "id": r.id, "name": r.name, "desc": r.desc, "size": r.size, "size_formatted": filesizeformat(r.size), "mtime": r.last_modified, "mtime_relative": translate_seahub_time(r.last_modified), "encrypted": r.encrypted, "permission": r.permission, "owner": r.user, "owner_nickname": email2nickname(r.user), "share_from_me": True if username == r.user else False, } repos.append(repo) group_info['repos'] = repos groups.append(group_info) return Response(groups)
def post(self, request, group_id): """ Bulk add group members. Permission checking: 1. only admin can perform this action. """ # argument check group_id = int(group_id) group = ccnet_api.get_group(group_id) if not group: error_msg = 'Group %d not found.' % group_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) emails = request.POST.getlist('email', '') if not emails: error_msg = 'Email invalid.' return api_error(status.HTTP_400_BAD_REQUEST, error_msg) result = {} result['failed'] = [] result['success'] = [] emails_need_add = [] for email in emails: try: User.objects.get(email=email) except User.DoesNotExist: result['failed'].append({ 'email': email, 'error_msg': 'User %s not found.' % email }) continue if is_group_member(group_id, email, in_structure=False): result['failed'].append({ 'email': email, 'error_msg': 'User %s is already a group member.' % email2nickname(email) }) continue emails_need_add.append(email) # Add user to group. for email in emails_need_add: try: ccnet_api.group_add_member(group_id, group.creator_name, email) member_info = get_group_member_info(request, group_id, email) result['success'].append(member_info) except Exception as e: logger.error(e) result['failed'].append({ 'email': email, 'error_msg': 'Internal Server Error' }) return Response(result)
def format_grpmsg_reply(self, notice): d = notice.grpmsg_reply_detail_to_dict() message = d.get('reply_msg') notice.group_msg_reply_url = reverse('msg_reply_new') notice.group_msg_reply_from = escape(email2nickname(d['reply_from'])) notice.group_msg_reply_from_avatar_url = self.get_avatar_url(d['reply_from']) notice.grp_reply_msg = message return notice
def format_priv_file_share_msg(self, notice): d = json.loads(notice.detail) priv_share_token = d['priv_share_token'] notice.priv_shared_file_url = reverse('view_priv_shared_file', args=[priv_share_token]) notice.notice_from = escape(email2nickname(d['share_from'])) notice.priv_shared_file_name = d['file_name'] notice.avatar_src = self.get_avatar_src(d['share_from']) return notice
def grpmsg_added_cb(sender, **kwargs): group_id = kwargs['group_id'] from_email = kwargs['from_email'] group_members = seaserv.get_group_members(int(group_id)) notify_members = [ x.user_name for x in group_members if x.user_name != from_email ] detail = group_msg_to_json(group_id, email2nickname(from_email)) UserNotification.objects.bulk_add_group_msg_notices(notify_members, detail)
def get(self, request): """ List all starred file/folder. Permission checking: 1. all authenticated user can perform this action. """ email = request.user.username all_starred_items = UserStarredFiles.objects.filter(email=email) repo_dict = {} for starred_item in all_starred_items: repo_id = starred_item.repo_id if repo_id not in repo_dict: repo = seafile_api.get_repo(repo_id) if repo: repo_dict[repo_id] = repo starred_repos = [] starred_folders = [] starred_files = [] for starred_item in all_starred_items: repo_id = starred_item.repo_id if repo_id not in repo_dict: continue path = starred_item.path if starred_item.is_dir: if not seafile_api.get_dir_id_by_path(repo_id, path): continue else: if not seafile_api.get_file_id_by_path(repo_id, path): continue repo = repo_dict[repo_id] item_info = self.get_starred_item_info(repo, starred_item) email = starred_item.email item_info['user_email'] = email item_info['user_name'] = email2nickname(email) item_info['user_contact_email'] = email2contact_email(email) if path == '/': starred_repos.append(item_info) elif starred_item.is_dir: starred_folders.append(item_info) else: starred_files.append(item_info) starred_repos.sort(lambda x, y: cmp(y['mtime'], x['mtime'])) starred_folders.sort(lambda x, y: cmp(y['mtime'], x['mtime'])) starred_files.sort(lambda x, y: cmp(y['mtime'], x['mtime'])) return Response({'starred_item_list': starred_repos + \ starred_folders + starred_files})
def get(self, request, repo_id): """ Return repo info Permission checking: 1. all authenticated user can perform this action. """ # resource check repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) # permission check permission = check_folder_permission(request, repo_id, '/') if permission is None: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) username = request.user.username lib_need_decrypt = False if repo.encrypted \ and not seafile_api.is_password_set(repo.id, username): lib_need_decrypt = True repo_owner = get_repo_owner(request, repo_id) try: has_been_shared_out = repo_has_been_shared_out(request, repo_id) except Exception as e: has_been_shared_out = False logger.error(e) result = { "repo_id": repo.id, "repo_name": repo.name, "owner_email": repo_owner, "owner_name": email2nickname(repo_owner), "owner_contact_email": email2contact_email(repo_owner), "size": repo.size, "encrypted": repo.encrypted, "file_count": repo.file_count, "permission": permission, "no_quota": True if seafile_api.check_quota(repo_id) < 0 else False, "is_admin": is_repo_admin(username, repo_id), "is_virtual": repo.is_virtual, "has_been_shared_out": has_been_shared_out, "lib_need_decrypt": lib_need_decrypt, "last_modified": timestamp_to_isoformat_timestr(repo.last_modify), } return Response(result)
def is_group_repo_staff(request, repo_id, username): is_staff = False repo_owner = get_repo_owner(request, repo_id) if '@seafile_group' in repo_owner: group_id = email2nickname(repo_owner) is_staff = seaserv.check_group_staff(group_id, username) return is_staff
def format_user_message(self): """ Arguments: - `self`: """ msg_from = self.detail nickname = email2nickname(msg_from) msg = _( u"You have recieved a <a href='%(href)s'>new message</a> from %(user)s." ) % { 'user': nickname, 'href': reverse('user_msg_list', args=[msg_from]), } return msg
def format_repo_share_to_group_msg(self, notice): d = json.loads(notice.detail) repo_id = d['repo_id'] repo = seafile_api.get_repo(repo_id) group_id = d['group_id'] group = ccnet_api.get_group(group_id) notice.repo_url = HASH_URLS["VIEW_COMMON_LIB_DIR"] % {'repo_id': repo_id, 'path': ''} notice.notice_from = escape(email2nickname(d['share_from'])) notice.repo_name = repo.name notice.avatar_src = self.get_avatar_src(d['share_from']) notice.group_url = HASH_URLS['GROUP_INFO'] % {'group_id': group.id} notice.group_name = group.group_name return notice
def format_draft_reviewer_msg(self): try: d = json.loads(self.detail) except Exception as e: logger.error(e) return _("Internal error") draft_id = d['draft_id'] from_user = d['from_user'] msg = _("%(from_user)s has sent you a request for <a href='%(file_url)s'>draft #%(draft_id)s</a>") % { 'draft_id': draft_id, 'file_url': reverse('drafts:draft', args=[draft_id]), 'from_user': escape(email2nickname(from_user)) } return msg
def format_draft_comment_msg(self): try: d = json.loads(self.detail) except Exception as e: logger.error(e) return _("Internal error") draft_id = d['draft_id'] author = d['author'] msg = _("<a href='%(file_url)s'>Draft #%(draft_id)s</a> has a new comment from user %(author)s") % { 'draft_id': draft_id, 'file_url': reverse('drafts:draft', args=[draft_id]), 'author': escape(email2nickname(author)), } return msg
def test_can_get(self): self.login_as(self.user) resp = self.client.get(self.url) self.assertEqual(200, resp.status_code) json_resp = json.loads(resp.content) assert json_resp["user_list"] assert json_resp["user_list"][0] assert json_resp["user_list"][0] assert json_resp["user_list"][0]['permission'] == 'rw' assert json_resp["user_list"][0]['avatar_url'] assert json_resp["user_list"][0][ 'contact_email'] == self.admin.username assert json_resp["user_list"][0]['email'] == self.admin.username assert json_resp["user_list"][0]['name'] == email2nickname( self.admin.username)
def get_user_info(email, org_id): info = {} info['email'] = email info['name'] = email2nickname(email) info['contact_email'] = email2contact_email(email) try: info['quota_usage'] = get_org_user_self_usage(org_id, email) info['quota_total'] = get_org_user_quota(org_id, email) except SearpcError as e: logger.error(e) info['quota_usage'] = -1 info['quota_total'] = -1 return info
def get_account_info(user): email = user.username d_profile = DetailedProfile.objects.get_detailed_profile_by_user(email) info = {} info['email'] = email info['name'] = email2nickname(email) info['department'] = d_profile.department if d_profile else '' info['id'] = user.id info['is_staff'] = user.is_staff info['is_active'] = user.is_active info['create_time'] = user.ctime info['total'] = seafile_api.get_user_quota(email) info['usage'] = seafile_api.get_user_self_usage(email) return info
def to_dict(self): uuid = self.origin_file_uuid file_path = posixpath.join(uuid.parent_path, uuid.filename) # TODO: refactor uuid return { 'id': self.pk, 'owner': self.username, 'owner_nickname': email2nickname(self.username), 'origin_repo_id': self.origin_repo_id, 'origin_file_path': file_path, 'origin_file_version': self.origin_file_version, 'draft_repo_id': self.draft_repo_id, 'draft_file_path': self.draft_file_path, 'created_at': datetime_to_isoformat_timestr(self.created_at), 'updated_at': datetime_to_isoformat_timestr(self.updated_at), }
def format_group_join_request(self, notice): d = json.loads(notice.detail) username = d['username'] group_id = d['group_id'] join_request_msg = d['join_request_msg'] group = ccnet_api.get_group(group_id) notice.grpjoin_user_profile_url = reverse('user_profile', args=[username]) notice.grpjoin_group_url = HASH_URLS['GROUP_MEMBERS'] % {'group_id': group_id} notice.notice_from = escape(email2nickname(username)) notice.grpjoin_group_name = group.group_name notice.grpjoin_request_msg = join_request_msg notice.avatar_src = self.get_avatar_src(username) return notice
def to_dict(self): uuid = FileUUIDMap.objects.get_fileuuidmap_by_uuid( self.origin_file_uuid) file_path = posixpath.join(uuid.parent_path, uuid.filename) return { 'id': self.pk, 'owner': self.username, 'owner_nickname': email2nickname(self.username), 'origin_repo_id': self.origin_repo_id, 'origin_file_path': file_path, 'origin_file_version': self.origin_file_version, 'draft_file_path': self.draft_file_path, 'created_at': datetime_to_isoformat_timestr(self.created_at), 'updated_at': datetime_to_isoformat_timestr(self.updated_at), }
def get_institution_user_info(user_obj, institution): info = {} info['email'] = user_obj.email info['name'] = email2nickname(user_obj.email) info['contact_email'] = email2contact_email(user_obj.email) info['quota_usage'], info['quota_total'] = get_user_quota_usage_and_total(user_obj.email) info['create_time'] = timestamp_to_isoformat_timestr(user_obj.ctime) info['is_active'] = user_obj.is_active info['is_institution_admin'] = is_institution_admin(user_obj.email, institution) last_login_obj = UserLastLogin.objects.get_by_username(user_obj.email) info['last_login'] = datetime_to_isoformat_timestr(last_login_obj.last_login) if last_login_obj else '' return info
def format_repo_share_to_group_msg(self, notice): d = json.loads(notice.detail) repo_id = d['repo_id'] repo = seafile_api.get_repo(repo_id) group_id = d['group_id'] group = ccnet_api.get_group(group_id) notice.repo_url = reverse("view_common_lib_dir", args=[repo_id, '']) notice.notice_from = escape(email2nickname(d['share_from'])) notice.repo_name = repo.name notice.avatar_src = self.get_avatar_src(d['share_from']) notice.group_url = reverse("group_info", args=[group.id]) notice.group_name = group.group_name return notice
def get_share_link_info(fileshare): data = {} token = fileshare.token repo_id = fileshare.repo_id try: repo = seafile_api.get_repo(repo_id) except Exception as e: logger.error(e) repo = None path = fileshare.path if path: obj_name = '/' if path == '/' else os.path.basename(path.rstrip('/')) else: obj_name = '' if fileshare.expire_date: expire_date = datetime_to_isoformat_timestr(fileshare.expire_date) else: expire_date = '' if fileshare.ctime: ctime = datetime_to_isoformat_timestr(fileshare.ctime) else: ctime = '' ccnet_email = fileshare.username data['creator_email'] = ccnet_email data['creator_name'] = email2nickname(ccnet_email) data['creator_contact_email'] = email2contact_email(ccnet_email) data['repo_id'] = repo_id data['repo_name'] = repo.repo_name if repo else '' data['path'] = path data['obj_name'] = obj_name data['is_dir'] = True if fileshare.s_type == 'd' else False data['token'] = token data['link'] = gen_shared_link(token, fileshare.s_type) data['view_cnt'] = fileshare.view_cnt data['ctime'] = ctime data['expire_date'] = expire_date data['is_expired'] = fileshare.is_expired() data['permissions'] = fileshare.get_permissions() return data
def get(self, request, repo_id, format=None): """ List repo share invitations. """ # argument check path = request.GET.get('path', None) if not path: return api_error(status.HTTP_400_BAD_REQUEST, 'path invalid.') # recourse check repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) if seafile_api.get_dir_id_by_path(repo.id, path) is None: return api_error(status.HTTP_404_NOT_FOUND, 'Folder %s not found.' % path) # permission check username = request.user.username if is_org_context(request): repo_owner = seafile_api.get_org_repo_owner(repo_id) else: repo_owner = seafile_api.get_repo_owner(repo_id) if username != repo_owner and not is_repo_admin(username, repo_id): error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) # main shared_list = list() try: shared_queryset = RepoShareInvitation.objects.list_by_repo_id_and_path( repo_id, path) except Exception as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) for obj in shared_queryset: data = obj.invitation.to_dict() data['permission'] = obj.permission data['inviter_name'] = email2nickname(obj.invitation.inviter) shared_list.append(data) return Response({'repo_share_invitation_list': shared_list})
def get(self, request, repo_id): """ Return repo info Permission checking: 1. all authenticated user can perform this action. """ # resource check repo = seafile_api.get_repo(repo_id) if not repo: error_msg = 'Library %s not found.' % repo_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) # permission check permission = check_folder_permission(request, repo_id, '/') if permission is None: error_msg = 'Permission denied.' return api_error(status.HTTP_403_FORBIDDEN, error_msg) username = request.user.username repo_owner = get_repo_owner(request, repo_id) try: has_been_shared_out = repo_has_been_shared_out(request, repo_id) except Exception as e: has_been_shared_out = False logger.error(e) result = { "repo_id": repo.id, "repo_name": repo.name, "owner_email": repo_owner, "owner_name": email2nickname(repo_owner), "owner_contact_email": email2contact_email(repo_owner), "size": repo.size, "encrypted": repo.encrypted, "file_count": repo.file_count, "permission": permission, "no_quota": True if seafile_api.check_quota(repo_id) < 0 else False, "is_admin": is_repo_admin(username, repo_id), "is_virtual": repo.is_virtual, "has_been_shared_out": has_been_shared_out, } return Response(result)
def get(self, request, format=None): if not request.user.admin_permissions.other_permission(): return api_error(status.HTTP_403_FORBIDDEN, 'Permission denied.') try: current_page = int(request.GET.get('page', '1')) per_page = int(request.GET.get('per_page', '50')) except ValueError: current_page = 1 per_page = 50 platform = request.GET.get('platform', None) start = (current_page - 1) * per_page end = current_page * per_page + 1 devices = TokenV2.objects.get_devices(platform, start, end) if len(devices) == end - start: devices = devices[:per_page] has_next_page = True else: has_next_page = False return_results = [] for device in devices: result = {} result['client_version'] = device.client_version result['device_id'] = device.device_id result['device_name'] = device.device_name result['last_accessed'] = datetime_to_isoformat_timestr(device.last_accessed) result['last_login_ip'] = device.last_login_ip result['user'] = device.user result['user_name'] = email2nickname(device.user) result['platform'] = device.platform result['is_desktop_client'] = False if result['platform'] in DESKTOP_PLATFORMS: result['is_desktop_client'] = True return_results.append(result) page_info = { 'has_next_page': has_next_page, 'current_page': current_page } return Response({"page_info": page_info, "devices": return_results})
def get(self, request, org_id, email): """Org admin list user owned repos """ # resource check org_id = int(org_id) if not ccnet_api.get_org_by_id(org_id): error_msg = 'Organization %s not found.' % org_id return api_error(status.HTTP_404_NOT_FOUND, error_msg) try: user = User.objects.get(email=email) except User.DoesNotExist: err_msg = 'User %s not found.' % email return api_error(status.HTTP_404_NOT_FOUND, err_msg) # permission check if not ccnet_api.org_user_exists(org_id, email): err_msg = _('User %s not found in organization.') % email return api_error(status.HTTP_404_NOT_FOUND, err_msg) # list repos repo_info_list = list() owned_repos = seafile_api.get_org_owned_repo_list(org_id, email) for r in owned_repos: # do not return virtual repos if r.is_virtual: continue repo_info = { "repo_id": r.id, "repo_name": r.name, "owner_email": email, "owner_name": email2nickname(email), "owner_contact_email": email2contact_email(email), "last_modified": timestamp_to_isoformat_timestr(r.last_modify), "modifier_email": r.last_modifier, "size": r.size, "encrypted": r.encrypted, "permission": 'rw', # Always have read-write permission to owned repo "status": normalize_repo_status_code(r.status), } repo_info_list.append(repo_info) return Response({'repo_list': repo_info_list})
def format_priv_file_share_msg(self): """ Arguments: - `self`: """ d = json.loads(self.detail) share_from = email2nickname(d['share_from']) file_name = d['file_name'] priv_share_token = d['priv_share_token'] msg = _(u"%(user)s has shared a file named <a href='%(href)s'>%(file_name)s</a> to you.") % { 'user': escape(share_from), 'href': reverse('view_priv_shared_file', args=[priv_share_token]), 'file_name': file_name, } return msg
def format_searched_user_result(request, users, size): results = [] for email in users: url, is_default, date_uploaded = api_avatar_url(email, size) results.append({ "email": email, "avatar_url": request.build_absolute_uri(url), "name": email2nickname(email), "contact_email": Profile.objects.get_contact_email_by_user(email), }) return results
def get(self, request): db_users = ccnet_api.get_emailusers('DB', -1, -1) ldap_import_users = ccnet_api.get_emailusers('LDAPImport', -1, -1) all_users = db_users + ldap_import_users head = [ _("Email"), _("Name"), _("Contact Email"), _("Space Usage") + "(MB)", _("Space Quota") + "(MB)" ] data_list = [] for user in all_users: user_email = user.email user_name = email2nickname(user_email) user_contact_email = email2contact_email(user_email) _populate_user_quota_usage(user) space_usage_MB = byte_to_mb(user.space_usage) space_quota_MB = byte_to_mb(user.space_quota) row = [ user_email, user_name, user_contact_email, space_usage_MB, space_quota_MB ] data_list.append(row) excel_name = 'User Storage' try: wb = write_xls('users', head, data_list) except Exception as e: logger.error(e) error_msg = 'Internal Server Error' return api_error(status.HTTP_500_INTERNAL_SERVER_ERROR, error_msg) response = HttpResponse(content_type='application/ms-excel') response[ 'Content-Disposition'] = 'attachment; filename=%s.xlsx' % excel_name wb.save(response) return response
def get_org_user_info(self, user, org): user_info = {} user_info['org_id'] = org.org_id user_info['active'] = user.is_active user_info['email'] = user.email user_info['name'] = email2nickname(user.email) user_info['contact_email'] = email2contact_email(user.email) org_user_quota = seafile_api.get_org_user_quota(org.org_id, user.email) user_info['quota_total'] = org_user_quota / get_file_size_unit('MB') org_user_quota_usage = seafile_api.get_org_user_quota_usage( org.org_id, user.email) user_info['quota_usage'] = org_user_quota_usage / get_file_size_unit( 'MB') return user_info
def get_org_user_info(org_id, email): user_info = {} user_obj = User.objects.get(email=email) user_info['org_id'] = org_id user_info['active'] = user_obj.is_active user_info['email'] = email user_info['name'] = email2nickname(email) user_info['contact_email'] = email2contact_email(email) org_user_quota = seafile_api.get_org_user_quota(org_id, email) user_info['quota_total'] = org_user_quota / get_file_size_unit('MB') org_user_quota_usage = seafile_api.get_org_user_quota_usage(org_id, email) user_info['quota_usage'] = org_user_quota_usage / get_file_size_unit('MB') return user_info
def format_add_user_to_group(self, notice): d = json.loads(notice.detail) group_staff = d['group_staff'] group_id = d['group_id'] group = ccnet_api.get_group(group_id) if not group: logger.info('group: %s not found', group_id) return None notice.notice_from = escape(email2nickname(group_staff)) notice.avatar_src = self.get_avatar_src(group_staff) notice.group_staff_profile_url = reverse('user_profile', args=[group_staff]) notice.group_url = reverse('dtable') notice.group_name = group.group_name return notice
def list_draft_by_username(self, username, status='open'): """list all user drafts If with_reviews is true, return the draft associated review """ repo_cache = {} def get_repo_with_cache(repo_id, repo_cache): """return repo object Avoid loading the same repo multiple times """ if repo_id in repo_cache: return repo_cache[repo_id] repo = seafile_api.get_repo(repo_id) repo_cache[repo_id] = repo return repo data = [] qs = self.filter(username=username, status=status) for d in qs: # If repo does not exist, no related items are displayed. repo = get_repo_with_cache(d.origin_repo_id, repo_cache) if not repo: continue uuid = FileUUIDMap.objects.get_fileuuidmap_by_uuid( d.origin_file_uuid) file_path = posixpath.join(uuid.parent_path, uuid.filename) draft = {} draft['id'] = d.id draft['owner'] = d.username draft['repo_name'] = repo.name draft['owner_nickname'] = email2nickname(d.username) draft['origin_repo_id'] = d.origin_repo_id draft['origin_file_path'] = file_path draft['origin_file_version'] = d.origin_file_version draft['draft_file_path'] = d.draft_file_path draft['created_at'] = datetime_to_isoformat_timestr(d.created_at) draft['updated_at'] = datetime_to_isoformat_timestr(d.updated_at) draft['status'] = d.status data.append(draft) return data
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 list_draft_by_repo_id(self, repo_id, status='open'): """list draft by repo id """ drafts = [] qs = self.filter(origin_repo_id=repo_id, status=status) for d in qs: draft = {} draft['id'] = d.id draft['owner_nickname'] = email2nickname(d.username) draft['origin_repo_id'] = d.origin_repo_id draft['draft_file_path'] = d.draft_file_path draft['created_at'] = datetime_to_isoformat_timestr(d.created_at) drafts.append(draft) return drafts
def get_user_info(email): user = User.objects.get(email=email) profile = Profile.objects.get_profile_by_user(email) info = {} info['email'] = email info['name'] = email2nickname(email) info[ 'contact_email'] = profile.contact_email if profile and profile.contact_email else '' info['login_id'] = profile.login_id if profile and profile.login_id else '' info['is_staff'] = user.is_staff info['is_active'] = user.is_active info['reference_id'] = user.reference_id if user.reference_id else '' orgs = ccnet_api.get_orgs_by_user(email) try: if orgs: org_id = orgs[0].org_id info['org_id'] = org_id info['org_name'] = orgs[0].org_name info['quota_usage'] = seafile_api.get_org_user_quota_usage( org_id, user.email) info['quota_total'] = seafile_api.get_org_user_quota( org_id, user.email) else: info['quota_usage'] = seafile_api.get_user_self_usage(user.email) info['quota_total'] = seafile_api.get_user_quota(user.email) except Exception as e: logger.error(e) info['quota_usage'] = -1 info['quota_total'] = -1 info['create_time'] = timestamp_to_isoformat_timestr(user.ctime) info['has_default_device'] = True if default_device(user) else False info['is_force_2fa'] = UserOptions.objects.is_force_2fa(email) if getattr(settings, 'MULTI_INSTITUTION', False): info['institution'] = profile.institution if profile else '' info['role'] = get_user_role(user) return info
def attention(request): """ Handle ajax request to query group members used in autocomplete. """ user = request.user.username name_str = request.GET.get('name_startsWith') gids = request.GET.get('gids', '') result = [] members = [] for gid in gids.split('_'): try: gid = int(gid) except ValueError: continue if not is_group_user(gid, user): continue # Get all group users members += get_group_members(gid) member_names = [] for m in members: if len(result) == 10: # Return at most 10 results. break if m.user_name == user: continue if m.user_name in member_names: # Remove duplicated member names continue else: member_names.append(m.user_name) from seahub.base.templatetags.seahub_tags import email2nickname, char2pinyin nickname = email2nickname(m.user_name) pinyin = char2pinyin(nickname) if nickname.startswith(name_str) or pinyin.startswith(name_str): result.append({'contact_name': nickname}) content_type = 'application/json; charset=utf-8' return HttpResponse(json.dumps(result), content_type=content_type)
def get(self, request): """List all admins from database and ldap imported """ try: db_users = ccnet_api.get_emailusers('DB', -1, -1) ldap_imported_users = ccnet_api.get_emailusers('LDAPImport', -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) admin_users = [] for user in db_users + ldap_imported_users: if user.is_staff is True: admin_users.append(user) admin_users_info = [] for user in admin_users: user_info = {} profile = Profile.objects.get_profile_by_user(user.email) user_info['email'] = user.email user_info['name'] = email2nickname(user.email) user_info['contact_email'] = profile.contact_email if profile and profile.contact_email else '' user_info['login_id'] = profile.login_id if profile and profile.login_id else '' user_info['is_staff'] = user.is_staff user_info['is_active'] = user.is_active user_info['quota_total'] = seafile_api.get_user_quota(user.email) user_info['quota_usage'] = seafile_api.get_user_self_usage(user.email) user_info['create_time'] = timestamp_to_isoformat_timestr(user.ctime) user_info['last_login'] = UserLastLogin.objects.get_by_username(user.email).last_login if UserLastLogin.objects.get_by_username(user.email) else '' try: admin_role = AdminRole.objects.get_admin_role(user.email) user_info['admin_role'] = admin_role.role except AdminRole.DoesNotExist: user_info['admin_role'] = DEFAULT_ADMIN admin_users_info.append(user_info) result = { 'admin_user_list': admin_users_info, } return Response(result)
def format_repo_share_msg(self): """ Arguments: - `self`: """ try: d = json.loads(self.detail) except Exception as e: logger.error(e) return _(u"Internal error") share_from = email2nickname(d['share_from']) repo_id = d['repo_id'] path = d.get('path', '/') org_id = d.get('org_id', None) repo = None try: if path == '/': repo = seafile_api.get_repo(repo_id) else: if org_id: owner = seafile_api.get_org_repo_owner(repo_id) repo = seafile_api.get_org_virtual_repo( org_id, repo_id, path, owner) else: owner = seafile_api.get_repo_owner(repo_id) repo = seafile_api.get_virtual_repo(repo_id, path, owner) except Exception as e: logger.error(e) return None if repo is None: self.delete() return None msg = _( u"%(user)s has shared a library named <a href='%(href)s'>%(repo_name)s</a> to you." ) % { 'user': escape(share_from), 'href': reverse('view_common_lib_dir', args=[repo.id, '']), 'repo_name': escape(repo.name), } return msg