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
