def get_documentlist_js(request):
response = {}
status = 405
if request.is_ajax() and request.method == 'POST':
status = 200
response['documents'] = documents_list(request)
response['team_members'] = []
for team_member in request.user.leader.all():
tm_object = {}
tm_object['id'] = team_member.member.id
tm_object['name'] = team_member.member.readable_name
tm_object['username'] = team_member.member.get_username()
tm_object['avatar'] = avatar_url(team_member.member, 80)
response['team_members'].append(tm_object)
serializer = PythonWithURLSerializer()
export_temps = serializer.serialize(ExportTemplate.objects.all())
response['export_templates'] = [obj['fields'] for obj in export_temps]
cit_styles = serializer.serialize(CitationStyle.objects.all())
response['citation_styles'] = [obj['fields'] for obj in cit_styles]
cit_locales = serializer.serialize(CitationLocale.objects.all())
response['citation_locales'] = [obj['fields'] for obj in cit_locales]
response['user'] = {}
response['user']['id'] = request.user.id
response['user']['name'] = request.user.readable_name
response['user']['username'] = request.user.get_username()
response['user']['avatar'] = avatar_url(request.user, 80)
response['access_rights'] = get_accessrights(
AccessRight.objects.filter(document__owner=request.user))
return JsonResponse(response, status=status)
def get_document(self):
response = dict()
response['type'] = 'document_data'
response['document'] = dict()
response['document']['id']=self.document.id
response['document']['title']=self.document.title
response['document']['contents']=self.document.contents
response['document']['metadata']=self.document.metadata
response['document']['settings']=self.document.settings
response['document']['access_rights'] = get_accessrights(AccessRight.objects.filter(document__owner=self.document.owner))
response['document']['owner'] = dict()
response['document']['owner']['id']=self.document.owner.id
response['document']['owner']['name']=self.document.owner.readable_name
response['document']['owner']['avatar']=avatar_url(self.document.owner,80)
response['document']['owner']['team_members']=[]
for team_member in self.document.owner.leader.all():
tm_object = dict()
tm_object['id'] = team_member.member.id
tm_object['name'] = team_member.member.readable_name
tm_object['avatar'] = avatar_url(team_member.member,80)
response['document']['owner']['team_members'].append(tm_object)
response['document_values'] = dict()
response['document_values']['is_owner']=self.is_owner
response['document_values']['rights'] = self.access_rights
if self.is_new:
response['document_values']['is_new'] = True
if not self.is_owner:
response['user']=dict()
response['user']['id']=self.user.id
response['user']['name']=self.user.readable_name
response['user']['avatar']=avatar_url(self.user,80)
if self.in_control:
response['document_values']['control']=True
response['document_values']['session_id']= self.id
self.write_message(response)
def index(request):
user = request.user
visit_num = UList.objects.count() + 1
ip, is_routable = get_client_ip(request)
try:
data = str(datetime.datetime.now()) + ', ip:' + str(
ip) + f', server_name: {request.META["SERVER_NAME"]}'
except:
data = str(datetime.datetime.now())
if request.user.is_authenticated:
visit = UList(visitor=user,
user=user,
data=data,
image=str(avatar_url(user)))
else:
visit = UList(
visitor=user,
data=data,
image=
'https://www.gravatar.com/avatar/d41d8cd98f00b204e9800998ecf8427e/?s=80'
)
visit.save()
# update avatars for auth user for old visits
if request.user.is_authenticated:
for obj in UList.objects.filter(user=user).exclude(
image=str(avatar_url(user))):
obj.image = str(avatar_url(user))
obj.save()
obj = UList.objects.all()
return render(request, "index.html", {"UList": obj, "counter": visit_num})
def test_gravatar_backup_setting(self):
avatar_tags.AVATAR_GRAVATAR_BACKUP = False
url = avatar_tags.avatar_url(self.user)
self.assertEquals(settings.AVATAR_DEFAULT_URL, url)
avatar_tags.AVATAR_GRAVATAR_BACKUP = True
url = avatar_tags.avatar_url(self.user)
self.assertTrue(url.startswith("http://www.gravatar.com/"))
def has_avatar(user, size=88):
"""
Used to pull the avatar from a user profile. If an image has not been set
no image will be returned.
Usage::
{% has_avatar model.user [size] %}
Be sure to attach .user to an object that contains a user relationship.
Example::
{% for officer in officers %}
{% has_avatar officer.user 64 %}
{% endfor %}
This will return an avatar image that is 64x64 pixels.
Note: This uses the 'django-avatar' package: https://github.com/jezdez/django-avatar
"""
if not isinstance(user, User):
try:
user = User.objects.get(username=user)
alt = unicode(user)
url = avatar_url(user, size)
except User.DoesNotExist:
url = AVATAR_DEFAULT_URL
alt = _("Default Avatar")
else:
alt = unicode(user)
url = avatar_url(user, size)
if url == AVATAR_DEFAULT_URL:
return ""
return """<img src="%s" alt="%s" width="%s" height="%s" />""" % (url, alt,
size, size)
def has_avatar(user, size=88):
"""
Used to pull the avatar from a user profile. If an image has not been set
no image will be returned.
Usage::
{% has_avatar model.user [size] %}
Be sure to attach .user to an object that contains a user relationship.
Example::
{% for officer in officers %}
{% has_avatar officer.user 64 %}
{% endfor %}
This will return an avatar image that is 64x64 pixels.
Note: This uses the 'django-avatar' package: https://github.com/jezdez/django-avatar
"""
if not isinstance(user, User):
try:
user = User.objects.get(username=user)
alt = unicode(user)
url = avatar_url(user, size)
except User.DoesNotExist:
url = AVATAR_DEFAULT_URL
alt = _("Default Avatar")
else:
alt = unicode(user)
url = avatar_url(user, size)
if url == AVATAR_DEFAULT_URL:
return ""
return """<img src="%s" alt="%s" width="%s" height="%s" />""" % (url, alt, size, size)
def get_booklist_js(request):
response = {}
status = 405
if request.is_ajax() and request.method == "POST":
status = 200
response["documents"] = documents_list(request)
books = Book.objects.filter(Q(owner=request.user) | Q(bookaccessright__user=request.user)).order_by("-updated")
response["books"] = []
for book in books:
access_right = (
"w" if book.owner == request.user else BookAccessRight.objects.get(user=request.user, book=book).rights
)
date_format = "%d/%m/%Y"
date_obj = dateutil.parser.parse(str(book.added))
added = date_obj.strftime(date_format)
date_obj = dateutil.parser.parse(str(book.updated))
updated = date_obj.strftime(date_format)
is_owner = False
if book.owner == request.user:
is_owner = True
chapters = []
for chapter in book.chapter_set.all():
chapters.append(
{
"text": chapter.text_id,
"number": chapter.number,
"part": chapter.part,
"title": chapter.text.title,
}
)
book_data = {
"id": book.id,
"title": book.title,
"is_owner": is_owner,
"owner": book.owner.id,
"owner_name": book.owner.readable_name,
"owner_avatar": avatar_url(book.owner, 80),
"added": added,
"updated": updated,
"rights": access_right,
"chapters": chapters,
"metadata": book.metadata,
"settings": book.settings,
}
if book.cover_image:
book_data["cover_image"] = book.cover_image.id
response["books"].append(book_data)
response["team_members"] = []
for team_member in request.user.leader.all():
tm_object = {}
tm_object["id"] = team_member.member.id
tm_object["name"] = team_member.member.readable_name
tm_object["avatar"] = avatar_url(team_member.member, 80)
response["team_members"].append(tm_object)
response["user"] = {}
response["user"]["id"] = request.user.id
response["user"]["name"] = request.user.readable_name
response["user"]["avatar"] = avatar_url(request.user, 80)
response["access_rights"] = get_accessrights(BookAccessRight.objects.filter(book__owner=request.user))
return HttpResponse(simplejson.dumps(response), content_type="application/json; charset=utf8", status=status)
def add_item_elements(self, handler, item):
"""Inject Activity Stream elements into an item"""
handler.addQuickElement('published', item['pubdate'].isoformat())
item['pubdate'] = None
# Author information.
if item['author_name'] is not None:
handler.startElement(u"author", {})
handler.addQuickElement(u"activity:object-type",
'http://activitystrea.ms/schema/1.0/person')
handler.addQuickElement(u"name", item['author_name'])
if item['author_email'] is not None:
handler.addQuickElement(u"email", item['author_email'])
if item['author_link'] is not None:
handler.addQuickElement(u"uri", item['author_link'])
handler.addQuickElement(u"id",
get_tag_uri(item['author_link'], item['pubdate']))
handler.addQuickElement(u"link", u"", {
'type': 'text/html', 'rel':'alternate',
'href': item['author_link']
})
handler.addQuickElement(u"link", u"", {
'type': 'image/jpeg', 'rel':'photo',
'media:width': '64', 'media:height': '64',
'href': self.feed['request'].build_absolute_uri(
avatar_url(item['obj'].claimed_by, 64)),
})
avatar_href = avatar_url(item['obj'].claimed_by, 64)
if avatar_href.startswith('/'):
avatar_href = self.feed['request'].build_absolute_uri(avatar_href)
handler.addQuickElement(u"link", u"", {
'type': 'image/jpeg', 'rel':'preview',
'media:width': '64', 'media:height': '64',
'href': avatar_href,
})
handler.endElement(u"author")
item['author_name'] = None
handler.addQuickElement('activity:verb', item['activity']['verb'])
a_object = item['activity']['object']
handler.startElement(u"activity:object", {})
handler.addQuickElement(u"activity:object-type", a_object['object-type'])
handler.addQuickElement(u"title", a_object['name'])
handler.addQuickElement(u"id", get_tag_uri(a_object['link'],
item['pubdate']))
handler.addQuickElement(u"link", '', {
'href': a_object['link'], 'rel':'alternate', 'type':'text/html'
})
handler.addQuickElement(u"link", u"", {
'type': 'image/jpeg', 'rel':'preview',
'media:width': a_object['preview']['width'],
'media:height': a_object['preview']['height'],
'href': a_object['preview']['href'],
})
handler.endElement(u"activity:object")
super(ActivityStreamAtomFeedGenerator, self).add_item_elements(handler, item)
def get_booklist_js(request):
response={}
status = 405
if request.is_ajax() and request.method == 'POST':
status = 200
response['documents'] = documents_list(request)
books = Book.objects.filter(Q(owner=request.user) | Q(bookaccessright__user=request.user)).order_by('-updated')
response['books']=[]
for book in books :
access_right = 'w' if book.owner == request.user else BookAccessRight.objects.get(user=request.user,book=book).rights
date_format = '%d/%m/%Y'
date_obj = dateutil.parser.parse(str(book.added))
added = date_obj.strftime(date_format)
date_obj = dateutil.parser.parse(str(book.updated))
updated = date_obj.strftime(date_format)
is_owner = False
if book.owner == request.user:
is_owner = True
chapters = []
for chapter in book.chapter_set.all():
chapters.append({'text': chapter.text_id, 'number': chapter.number, 'part': chapter.part, 'title': chapter.text.title})
book_data = {
'id': book.id,
'title': book.title,
'is_owner': is_owner,
'owner': book.owner.id,
'owner_name': book.owner.readable_name,
'owner_avatar': avatar_url(book.owner,80),
'added': added,
'updated': updated,
'rights': access_right,
'chapters': chapters,
'metadata': book.metadata,
'settings': book.settings
}
if book.cover_image:
book_data['cover_image'] = book.cover_image.id
response['books'].append(book_data)
response['team_members']=[]
for team_member in request.user.leader.all():
tm_object = {}
tm_object['id'] = team_member.member.id
tm_object['name'] = team_member.member.readable_name
tm_object['avatar'] = avatar_url(team_member.member,80)
response['team_members'].append(tm_object)
response['user']={}
response['user']['id']=request.user.id
response['user']['name']=request.user.readable_name
response['user']['avatar']=avatar_url(request.user,80)
response['access_rights'] = get_accessrights(BookAccessRight.objects.filter(book__owner=request.user))
return HttpResponse(
json.dumps(response),
content_type = 'application/json; charset=utf8',
status=status
)
def create_profile_index(profile):
# calculate counts and avatar
layers_count = get_objects_for_user(
profile, 'base.view_resourcebase').instance_of(Layer).count()
maps_count = get_objects_for_user(
profile, 'base.view_resourcebase').instance_of(Map).count()
documents_count = get_objects_for_user(
profile, 'base.view_resourcebase').instance_of(Document).count()
avatar_100 = avatar_url(profile, 240)
obj = ProfileIndex(meta={'id': profile.id},
id=profile.id,
username=profile.username,
first_name=profile.first_name,
last_name=profile.last_name,
profile=profile.profile,
organization=profile.organization,
position=profile.position,
type='user',
avatar_100=avatar_100,
layers_count=layers_count,
maps_count=maps_count,
documents_count=documents_count)
obj.save()
return obj.to_dict(include_meta=True)
def documents_list(request):
documents = Text.objects.filter(
Q(owner=request.user)
| Q(accessright__user=request.user)).order_by('-updated')
output_list = []
for document in documents:
access_right = 'w' if document.owner == request.user else AccessRight.objects.get(
user=request.user, text=document).rights
date_format = '%d/%m/%Y'
date_obj = dateutil.parser.parse(str(document.added))
added = date_obj.strftime(date_format)
date_obj = dateutil.parser.parse(str(document.updated))
updated = date_obj.strftime(date_format)
is_owner = False
if document.owner == request.user:
is_owner = True
output_list.append({
'id': document.id,
'title': document.title,
'is_owner': is_owner,
'owner': document.owner.id,
'owner_name': document.owner.readable_name,
'owner_avatar': avatar_url(document.owner, 80),
'added': added,
'updated': updated,
#'is_locked': document.is_locked(),
'rights': access_right
})
return output_list
def dehydrate(self, bundle):
a = bundle.obj
if self.get_resource_uri(bundle) == bundle.request.path:
# it's a detailed request so we add the mks & parties scores
mks_values = dict(a.get_mks_values())
members = []
for mk in Member.objects.filter(pk__in=mks_values.keys()).select_related('current_party'):
# TODO: this sucks, performance wise
current_party = mk.current_party
members.append (dict(name=mk.name,
score = mks_values[mk.id]['score'],
rank = mks_values[mk.id]['rank'],
volume = mks_values[mk.id]['volume'],
absolute_url = mk.get_absolute_url(),
party = current_party.name,
party_url = current_party.get_absolute_url(),
))
bundle.data['members'] = members
bundle.data['parties'] = [
dict(
name=x.name, score=a.party_score(x),
absolute_url=x.get_absolute_url()
) for x in Party.objects.prefetch_related('members')
]
bundle.data['votes'] = [
dict(title=v.vote.title, id=v.id, importance=v.importance,
score=v.score, reasoning=v.reasoning)
for v in bundle.obj.agendavotes.select_related()
]
bundle.data['editors'] = [
dict(absolute_url=e.get_absolute_url(), username=e.username,
avatar=avatar_url(e, 48))
for e in bundle.obj.editors.all()]
return bundle
def documents_list(request):
documents = Document.objects.filter(Q(owner=request.user) | Q(accessright__user=request.user)).order_by('-updated')
output_list=[]
for document in documents :
access_right = 'w' if document.owner == request.user else AccessRight.objects.get(user=request.user,document=document).rights
revisions = DocumentRevision.objects.filter(document=document)
revision_list = []
for revision in revisions:
revision_list.append({
'date': time.mktime(revision.date.utctimetuple()),
'note': revision.note,
'file_name': revision.file_name,
'pk': revision.pk
})
added = time.mktime(document.added.utctimetuple())
updated = time.mktime(document.updated.utctimetuple())
is_owner = False
if document.owner == request.user:
is_owner = True
output_list.append({
'id': document.id,
'title': document.title,
'is_owner': is_owner,
'owner': {
'id': document.owner.id,
'name': document.owner.readable_name,
'avatar': avatar_url(document.owner,80)
},
'added': added,
'updated': updated,
'rights': access_right,
'revisions': revision_list
})
return output_list
def documents_list(request):
documents = Text.objects.filter(Q(owner=request.user) | Q(accessright__user=request.user)).order_by('-updated')
output_list=[]
for document in documents :
access_right = 'w' if document.owner == request.user else AccessRight.objects.get(user=request.user,text=document).rights
date_format = '%d/%m/%Y'
date_obj = dateutil.parser.parse(str(document.added))
added = date_obj.strftime(date_format)
date_obj = dateutil.parser.parse(str(document.updated))
updated = date_obj.strftime(date_format)
is_owner = False
if document.owner == request.user:
is_owner = True
output_list.append({
'id': document.id,
'title': document.title,
'is_owner': is_owner,
'owner': document.owner.id,
'owner_name': document.owner.readable_name,
'owner_avatar': avatar_url(document.owner,80),
'added': added,
'updated': updated,
'is_locked': document.is_locked(),
'rights': access_right
})
return output_list
def documents_list(request):
documents = Document.objects.filter(Q(owner=request.user) | Q(accessright__user=request.user)).order_by('-updated')
output_list=[]
for document in documents :
access_right = 'w' if document.owner == request.user else AccessRight.objects.get(user=request.user,document=document).rights
revisions = DocumentRevision.objects.filter(document=document)
revision_list = []
for revision in revisions:
revision_list.append({
'date': time.mktime(revision.date.utctimetuple()),
'note': revision.note,
'file_name': revision.file_name,
'pk': revision.pk
})
added = time.mktime(document.added.utctimetuple())
updated = time.mktime(document.updated.utctimetuple())
is_owner = False
if document.owner == request.user:
is_owner = True
output_list.append({
'id': document.id,
'title': document.title,
'is_owner': is_owner,
'owner': {
'id': document.owner.id,
'name': document.owner.readable_name,
'avatar': avatar_url(document.owner,80)
},
'added': added,
'updated': updated,
'rights': access_right,
'revisions': revision_list
})
return output_list
def avatar(user, size=settings.AVATAR_DEFAULT_SIZE, **kwargs):
if has_avatar(user):
# Use assigned avatar
alt = six.text_type(user)
url = avatar_url(user, size)
kwargs.update({'alt': alt})
context = {
'user': user,
'url': url,
'size': size,
'kwargs': kwargs,
}
return render_to_string('avatar/avatar_tag.html', context)
else:
# Dynamically generate an avatar based on the user's initials
letter = '?'
if user.first_name:
letter = user.first_name[0].upper()
if user.last_name:
letter += user.last_name[0].upper()
elif user.username:
letter = user.username[0].upper()
colour_ix = int(hashlib.md5(str(user.id).encode()).hexdigest(), 16) % NUM_COLOURS
context = {'colour_ix': colour_ix, 'letter': letter, 'size': size, 'font_size': (size / 2)}
return render_to_string('accounts/dynamic_avatar.svg', context)
def get_avatar_url(comment):
ret = None
if comment.user is not None:
try:
return avatar_url(comment.user)
except Exception as exc:
pass
return get_user_avatar(comment)
def test_gravatar_backup_rating_setting(self):
avatar_tags.AVATAR_GRAVATAR_BACKUP = True
avatar_tags.AVATAR_GRAVATAR_BACKUP_RATING = 'x'
url = avatar_tags.avatar_url(self.user)
self.assertTrue("r=x" in url)
def avatar(self):
"""
Return user avatar url.
:return: user avatar url.
:rtype: unicode.
"""
return avatar_url(self)
def avatar_full_url(context, user, size=settings.AVATAR_DEFAULT_SIZE):
url = avatar_url(user, size)
if url.startswith("http"):
return url
if getattr(context, "request", None):
return context.request.build_absolute_uri(url)
## YAK!!!
site = Site.objects.get_current()
return "http://" + site.domain + url
def profile_post_save(instance, sender, **kwargs):
"""Make sure the user belongs by default to the anonymous group.
This will make sure that anonymous permissions will be granted to the new users."""
from django.contrib.auth.models import Group
anon_group, created = Group.objects.get_or_create(name='anonymous')
instance.groups.add(anon_group)
# keep in sync Profile email address with Account email address
if instance.email not in [u'', '', None] and not kwargs.get('raw', False):
EmailAddress.objects.filter(user=instance, primary=True).update(email=instance.email)
Profile.objects.filter(id=instance.id).update(avatar_100=avatar_url(instance, 100))
def user_to_dict(user):
"""
Convert a user to a dict for use in the seating front-end
"""
profile = WarwickGGUser.objects.get(user=user)
return {
'nickname': profile.long_name,
'avatar': avatar_url(user),
'user_id': user.id
}
def get_documentlist_js(request):
response = {}
status = 405
if request.is_ajax() and request.method == 'POST':
status = 200
response['documents'] = documents_list(request)
response['team_members'] = []
for team_member in request.user.leader.all():
tm_object = {}
tm_object['id'] = team_member.member.id
tm_object['name'] = team_member.member.readable_name
tm_object['avatar'] = avatar_url(team_member.member, 80)
response['team_members'].append(tm_object)
response['user'] = {}
response['user']['id'] = request.user.id
response['user']['name'] = request.user.readable_name
response['user']['avatar'] = avatar_url(request.user, 80)
response['access_rights'] = get_accessrights(
AccessRight.objects.filter(document__owner=request.user))
return JsonResponse(response, status=status)
def user_avatar(user, size=avatar_settings.AVATAR_DEFAULT_SIZE, **kwargs):
if not isinstance(user, get_user_model()):
try:
user = get_user(user)
alt = six.text_type(user)
url = avatar_url(user, size)
except get_user_model().DoesNotExist:
url = get_default_avatar_url()
alt = _("Default Avatar")
else:
alt = six.text_type(user)
url = avatar_url(user, size)
context = dict(kwargs, **{
'user': user,
'url': url,
'alt': alt,
'size': size,
})
ret = jinja_env.get_template('avatar/avatar_tag.html').render(**context)
return jinja2.Markup(ret)
def open(self, document_id):
print 'Websocket opened - redis'
self.user = self.get_current_user()
if int(document_id) == 0:
can_access = True
self.is_owner = True
self.access_rights = 'w'
self.is_new = True
self.document = Document.objects.create(owner_id=self.user.id)
else:
self.is_new = False
document = Document.objects.filter(id=int(document_id))
if len(document) > 0:
document = document[0]
self.document = document
if self.document.owner == self.user:
self.access_rights = 'w'
self.is_owner = True
can_access = True
else:
self.is_owner = False
access_rights = AccessRight.objects.filter(document=self.document, user=self.user)
if len(access_rights) > 0:
self.access_rights = access_rights[0].rights
can_access = True
else:
can_access = False
else:
can_access = False
if can_access:
self.channel = str(self.document.id)
self.listen_to_redis()
response = dict()
response['type'] = 'welcome'
self.write_message(response)
if self.pubsub_numsub(self.channel)==1:
participants = None
else:
participants = self.get_storage_object('participants_'+str(self.channel))
if participants == None or len(participants.keys()) == 0:
participants = {}
self.id = 0
self.in_control = True
else:
self.id = int(max(participants))+1
self.in_control = False
participants[self.id] = {
'key':self.id,
'id':self.user.id,
'name':self.user.readable_name,
'avatar':avatar_url(self.user,80)
}
self.set_storage_object('participants_'+str(self.channel),participants)
def seat_to_dict(seat: Seating):
"""
Convert a seat in the DB to a dict for use in the seating front-end
"""
profile = WarwickGGUser.objects.get(user=seat['user_id'])
return {
'nickname': profile.long_name,
'seat_id': seat['seat'],
'user_id': seat['user_id'],
'avatar': avatar_url(profile.user)
}
def get_context_data(self):
candidates = Nomination.objects.all()
rows = [[
candidate.nominee.name, candidate.statement,
avatar_url(candidate.nominee)
] for candidate in candidates]
return {
'title': self.title,
'headings': ['Name', 'Statement', 'Avatar URL'],
'rows': rows,
}
def get_documentlist_js(request):
response={}
status = 405
if request.is_ajax() and request.method == 'POST':
status = 200
response['documents'] = documents_list(request)
response['team_members']=[]
for team_member in request.user.leader.all():
tm_object = {}
tm_object['id'] = team_member.member.id
tm_object['name'] = team_member.member.readable_name
tm_object['avatar'] = avatar_url(team_member.member,80)
response['team_members'].append(tm_object)
response['user']={}
response['user']['id']=request.user.id
response['user']['name']=request.user.readable_name
response['user']['avatar']=avatar_url(request.user,80)
response['access_rights'] = get_accessrights(AccessRight.objects.filter(document__owner=request.user))
return JsonResponse(
response,
status=status
)
def get_documentlist_js(request):
response = {}
status = 405
if request.is_ajax() and request.method == 'POST':
status = 200
response['documents'] = documents_list(request)
response['team_members'] = []
for team_member in request.user.leader.all():
tm_object = {}
tm_object['id'] = team_member.member.id
tm_object['name'] = team_member.member.readable_name
tm_object['avatar'] = avatar_url(team_member.member, 80)
response['team_members'].append(tm_object)
response['user'] = {}
response['user']['id'] = request.user.id
response['user']['name'] = request.user.readable_name
response['user']['avatar'] = avatar_url(request.user, 80)
response['access_rights'] = get_accessrights(
AccessRight.objects.filter(text__owner=request.user))
return HttpResponse(simplejson.dumps(response),
content_type='application/json; charset=utf8',
status=status)
def write(self, outfile, encoding):
# Check for a callback param, validate it before use
callback = self.feed['request'].GET.get('callback', None)
if callback is not None:
if not validate_jsonp.is_valid_jsonp_callback_value(callback):
callback = None
items_out = []
for item in self.items:
avatar_href = avatar_url(item['obj'].claimed_by, 64)
if avatar_href.startswith('/'):
avatar_href = self.request.build_absolute_uri(avatar_href)
a_object = item['activity']['object']
item_out = {
'postedTime': item['pubdate'],
'verb': item['activity']['verb'],
'actor': {
'objectType': 'http://activitystrea.ms/schema/1.0/person',
'id': get_tag_uri(item['author_link'], item['pubdate']),
'displayName': item['author_name'],
'permalinkUrl': item['author_link'],
'image': {
'url': avatar_href,
'width':'64',
'height':'64',
}
},
'object': {
'objectType': a_object['object-type'],
'id': get_tag_uri(a_object['link'], item['pubdate']),
'displayName': a_object['name'],
'permalinkUrl': a_object['link'],
'image': {
'url': a_object['preview']['href'],
'width': a_object['preview']['width'],
'height': a_object['preview']['height'],
}
},
}
items_out.append(item_out)
data = {
"items": items_out
}
if callback: outfile.write('%s(' % callback)
outfile.write(json.dumps(data, default=self._encode_complex))
if callback: outfile.write(')')
def get_document(self):
response = dict()
response['type'] = 'document_data'
response['document'] = dict()
response['document']['id'] = self.document.id
response['document']['title'] = self.document.title
response['document']['contents'] = self.document.contents
response['document']['metadata'] = self.document.metadata
response['document']['settings'] = self.document.settings
response['document']['access_rights'] = get_accessrights(
AccessRight.objects.filter(document__owner=self.document.owner))
response['document']['owner'] = dict()
response['document']['owner']['id'] = self.document.owner.id
response['document']['owner'][
'name'] = self.document.owner.readable_name
response['document']['owner']['avatar'] = avatar_url(
self.document.owner, 80)
response['document']['owner']['team_members'] = []
for team_member in self.document.owner.leader.all():
tm_object = dict()
tm_object['id'] = team_member.member.id
tm_object['name'] = team_member.member.readable_name
tm_object['avatar'] = avatar_url(team_member.member, 80)
response['document']['owner']['team_members'].append(tm_object)
response['document_values'] = dict()
response['document_values']['is_owner'] = self.is_owner
response['document_values']['rights'] = self.access_rights
if self.is_new:
response['document_values']['is_new'] = True
if not self.is_owner:
response['user'] = dict()
response['user']['id'] = self.user.id
response['user']['name'] = self.user.readable_name
response['user']['avatar'] = avatar_url(self.user, 80)
if self.in_control:
response['document_values']['control'] = True
response['document_values']['session_id'] = self.id
self.write_message(response)
def get_documentlist_js(request):
response={}
status = 405
if request.is_ajax() and request.method == 'POST':
status = 200
response['documents'] = documents_list(request)
response['team_members']=[]
for team_member in request.user.leader.all():
tm_object = {}
tm_object['id'] = team_member.member.id
tm_object['name'] = team_member.member.readable_name
tm_object['avatar'] = avatar_url(team_member.member,80)
response['team_members'].append(tm_object)
response['user']={}
response['user']['id']=request.user.id
response['user']['name']=request.user.readable_name
response['user']['avatar']=avatar_url(request.user,80)
response['access_rights'] = get_accessrights(AccessRight.objects.filter(text__owner=request.user))
return HttpResponse(
simplejson.dumps(response),
content_type = 'application/json; charset=utf8',
status=status
)
def recipient_search(request):
term = request.GET.get("term")
users = User.objects.filter(username__icontains=term)
if request.GET.get("format") == "json":
data = []
for user in users:
avatar_img_url = avatar_url(user, size=50)
data.append({"id": user.username,
"url": reverse("user_page",args=(user.username,)),
"name": "%s" % user.username,
"img": avatar_img_url})
return HttpResponse(simplejson.dumps(data),
mimetype='application/json')
def recipient_search(request):
term = request.GET.get("term")
users = User.objects.filter(username__icontains=term)
if request.GET.get("format") == "json":
data = []
for user in users:
avatar_img_url = avatar_url(user, size=50)
data.append({"id": user.username,
"url": reverse("user_page",args=(user.username,)),
"name": "%s" % user.username,
"img": avatar_img_url})
return HttpResponse(simplejson.dumps(data),
content_type='application/json')
def send_participant_list(cls, document):
if document in DocumentWS.sessions:
participant_list = []
for waiter in cls.sessions[document].keys():
participant_list.append({
'key':waiter,
'id':cls.sessions[document][waiter].user.id,
'name':cls.sessions[document][waiter].user.readable_name,
'avatar':avatar_url(cls.sessions[document][waiter].user,80)
})
chat = {
"participant_list": participant_list,
"type": 'connections'
}
DocumentWS.send_updates(chat, document)
def recipient_search(request):
term = request.GET.get("term")
users = User.objects.filter(Q(first_name__icontains=term) |
Q(last_name__icontains=term) |
Q(username__icontains=term) |
Q(email__icontains=term))
if request.GET.get("format") == "json":
data = []
for user in users:
avatar_img_url = avatar_url(user, size=50)
data.append({"id": user.username,
"name": "%s %s"%(user.first_name, user.last_name),
"img": avatar_img_url})
return HttpResponse(json.dumps(data),
content_type='application/json')
def recipient_search(request):
term = request.GET.get("term")
users = User.objects.filter(Q(first_name__icontains=term)|
Q(last_name__icontains=term)|
Q(username__icontains=term)|
Q(email__icontains=term))
if request.GET.get("format") == "json":
data = []
for user in users:
avatar_img_url = avatar_url(user, size=50)
data.append({"id": user.username,
#"url": reverse("profile_detail",args=(user.username,)),
"url": '',
"name": "%s %s".strip() % (user.first_name, user.last_name) if user.first_name or user.last_name else user.username,
"img": avatar_img_url})
return HttpResponse(json.dumps(data),
mimetype='application/json')
def profile_post_save(instance, sender, **kwargs):
"""
Make sure the user belongs by default to the anonymous group.
This will make sure that anonymous permissions will be granted to the new users.
"""
from django.contrib.auth.models import Group
anon_group, created = Group.objects.get_or_create(name='anonymous')
instance.groups.add(anon_group)
# do not create email, when user-account signup code is in use
if getattr(instance, '_disable_account_creation', False):
return
# keep in sync Profile email address with Account email address
if instance.email not in [u'', '', None] and not kwargs.get('raw', False):
address, created = EmailAddress.objects.get_or_create(
user=instance, primary=True,
defaults={'email': instance.email, 'verified': False})
if not created:
EmailAddress.objects.filter(user=instance, primary=True).update(email=instance.email)
Profile.objects.filter(id=instance.id).update(avatar_100=avatar_url(instance, 100))
def send_participant_list(cls, document):
if document in DocumentWS.sessions:
participant_list = []
for waiter in cls.sessions[document].keys():
participant_list.append({
'key':
waiter,
'id':
cls.sessions[document][waiter].user.id,
'name':
cls.sessions[document][waiter].user.readable_name,
'avatar':
avatar_url(cls.sessions[document][waiter].user, 80)
})
chat = {
"participant_list": participant_list,
"type": 'connections'
}
DocumentWS.send_updates(chat, document)
def dehydrate(self, bundle):
a = bundle.obj
if self.get_resource_uri(bundle) == bundle.request.path:
# it's a detailed request so we add the mks & parties scores
mks_values = dict(a.get_mks_values())
members = []
for mk in Member.objects.filter(
pk__in=mks_values.keys()).select_related('current_party'):
# TODO: this sucks, performance wise
current_party = mk.current_party
members.append(
dict(
name=mk.name,
score=mks_values[mk.id]['score'],
rank=mks_values[mk.id]['rank'],
volume=mks_values[mk.id]['volume'],
absolute_url=mk.get_absolute_url(),
party=current_party.name,
party_url=current_party.get_absolute_url(),
))
bundle.data['members'] = members
bundle.data['parties'] = [
dict(name=x.name,
score=a.party_score(x),
absolute_url=x.get_absolute_url())
for x in Party.objects.prefetch_related('members')
]
bundle.data['votes'] = [
dict(title=v.vote.title,
id=v.id,
importance=v.importance,
score=v.score,
reasoning=v.reasoning)
for v in bundle.obj.agendavotes.select_related()
]
bundle.data['editors'] = [
dict(absolute_url=e.get_absolute_url(),
username=e.username,
avatar=avatar_url(e, 48))
for e in bundle.obj.editors.all()
]
return bundle
def send_participant_list(cls, document_id):
if document_id in WebSocket.sessions:
participant_list = []
for session_id, waiter in cls.sessions[
document_id
]['participants'].items():
access_rights = waiter.user_info.access_rights
if access_rights not in CAN_COMMUNICATE:
continue
participant_list.append({
'session_id': session_id,
'id': waiter.user_info.user.id,
'name': waiter.user_info.user.readable_name,
'avatar': avatar_url(waiter.user_info.user, 80)
})
message = {
"participant_list": participant_list,
"type": 'connections'
}
WebSocket.send_updates(message, document_id)
def send_participant_list(cls, document_id):
if document_id in WebSocket.sessions:
participant_list = []
for session_id, waiter in cls.sessions[
document_id
]['participants'].items():
access_rights = waiter.user_info.access_rights
if access_rights not in CAN_COMMUNICATE:
continue
participant_list.append({
'session_id': session_id,
'id': waiter.user_info.user.id,
'name': waiter.user_info.user.readable_name,
'avatar': avatar_url(waiter.user_info.user, 80)
})
message = {
"participant_list": participant_list,
"type": 'connections'
}
WebSocket.send_updates(message, document_id)
def item_description(self, item):
# TODO: Stick this in a template?
avatar_img = avatar_url(item.claimed_by, 64)
if avatar_img.startswith('/'):
avatar_img = self.request.build_absolute_uri(avatar_img)
badge_img = badge_url(item.badge, 64)
if badge_img.startswith('/'):
badge_img = self.request.build_absolute_uri(badge_img)
return """
<a href="%(claimed_by_url)s"><img src="%(avatar_img)s" width="64" height="64" /> %(claimed_by)s</a>
<a href="%(award_url)s">claimed</a> the badge
<a href="%(badge_url)s">"%(badge_title)s" <img src="%(badge_img)s" width="64" height="64" /></a>
""" % {
'avatar_img': avatar_img,
'badge_img': badge_img,
'claimed_by': item.claimed_by,
'claimed_by_url': item.claimed_by.get_absolute_url(),
'badge_title': item.badge.title,
'badge_url': item.badge.get_absolute_url(),
'award_url': item.get_absolute_url(),
}
def send_participant_list(cls, document_id):
if document_id in DocumentWS.sessions:
participant_list = []
for waiter in cls.sessions[document_id]['participants'].keys():
participant_list.append({
'session_id': waiter,
'id': cls.sessions[document_id]['participants'][
waiter
].user_info.user.id,
'name': cls.sessions[document_id]['participants'][
waiter
].user_info.user.readable_name,
'avatar': avatar_url(cls.sessions[document_id][
'participants'
][waiter].user_info.user, 80)
})
message = {
"participant_list": participant_list,
"type": 'connections'
}
DocumentWS.send_updates(message, document_id)
def __get_user_data(request, user_type):
response_data = []
q = request.REQUEST.get('q', None)
if q:
if user_type == USER_TYPE_SCIENTIST:
scientist_list = User.objects.filter(Q(userprofile__is_scientist=True),
Q(username=q) | Q(email__icontains=q)).exclude(Q(id=request.user.id))
elif user_type == USER_TYPE_PARTICIPANT:
scientist_list = User.objects.filter(Q(userprofile__is_participant=True),
Q(username=q) | Q(email__icontains=q)).exclude(Q(id=request.user.id))
for scientist in scientist_list:
response_data.append(
{
'id': scientist.id,
'avatar': avatar_url(scientist, 80),
'display_name': scientist.username,
'email': scientist.email
}
)
return response_data
def summary(self):
summary = {
'name': self.name,
'activity': self.activity.name,
'activity_icon_url': self.activity.icon_url,
'distance': self.distance,
'duration': self.get_duration_string(),
'pace': self.get_pace_string(),
'owner': {
'name': self.owner.get_full_name(),
'id': self.owner.id,
'username': self.owner.username,
'avatar_url': avatar_url(self.owner, 32)
},
'date': self.date,
'number': self.number,
}
if self.pk:
summary['details_url'] = self.get_absolute_url()
return summary
def send_participant_list(cls, document_id):
if document_id in DocumentWS.sessions:
participant_list = []
for waiter in cls.sessions[document_id]['participants'].keys():
participant_list.append({
'session_id':
waiter,
'id':
cls.sessions[document_id]['participants']
[waiter].user_info.user.id,
'name':
cls.sessions[document_id]['participants']
[waiter].user_info.user.readable_name,
'avatar':
avatar_url(
cls.sessions[document_id]['participants']
[waiter].user_info.user, 80)
})
message = {
"participant_list": participant_list,
"type": 'connections'
}
DocumentWS.send_updates(message, document_id)
def upload_avatar(request):
'''
Upload avatar
:param request:
:return:
'''
if request.method == 'POST':
avatar_file = request.FILES['file']
avatar = Avatar(
user=request.user,
primary=True,
)
try:
avatar.avatar.delete()
except Exception as e:
# TODO log e
pass
avatar.avatar.save(avatar_file.name, avatar_file)
avatar.save()
avatar.create_thumbnail(80)
return_data = json.dumps(
{'status': 'success', 'thumbnail_url': avatar_url(request.user, 80)})
return HttpResponse(return_data, mimetype='application/json')
return HttpResponseNotAllowed(['POST', ])
def dehydrate_avatar(self, bundle):
return avatar_url(bundle.obj, 48)
def dehydrate_editors(self, bundle):
return [
dict(absolute_url=e.get_absolute_url(), username=e.username,
avatar=avatar_url(e, 48))
for e in bundle.obj.editors.all()
]
def dehydrate_avatar_100(self, bundle):
return avatar_url(bundle.obj, 240)
def get_attribute(self, instance):
return build_absolute_uri(avatar_url(instance, self.avatar_size))
def compact(self):
"""Converts a standard and verbose 'perm_spec' into 'compact mode'.
- The method also recognizes special/internal security groups, like 'anonymous' and 'registered-members' and places
their permissions on a specific node called 'groups'.
- Every security group, different from the former ones, associated to a GeoNode 'GroupProfile', will be placed on a
node called 'organizations' instead.
e.g.:
```
{
"users": [
{
"id": 1001,
"username": "******",
"first_name": "",
"last_name": "",
"avatar": "",
"permissions": "manage",
"is_superuser": <bool>,
"is_staff": <bool>
}
],
"organizations": [],
"groups": [
{
"id": 3,
"title": "Registered Members",
"name": "registered-members",
"permissions": "edit"
},
{
"id": 2,
"title": "anonymous",
"name": "anonymous",
"permissions": "download"
}
]
}
```
"""
json = {}
user_perms = []
group_perms = []
anonymous_perms = None
contributors_perms = None
organization_perms = []
for _k in self.users:
_perms = self.users[_k]
if isinstance(_k, str):
_k = get_user_model().objects.get(username=_k)
if not _k.is_anonymous and _k.username != 'AnonymousUser':
avatar = build_absolute_uri(avatar_url(_k, 240))
user = _User(_k.id, _k.username, _k.last_name, _k.first_name,
avatar, _k.is_superuser, _k.is_staff)
is_owner = _k == self._resource.owner
user_perms.append({
'id':
user.id,
'username':
user.username,
'first_name':
user.first_name,
'last_name':
user.last_name,
'avatar':
user.avatar,
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype, is_owner),
'is_superuser':
user.is_superuser,
'is_staff':
user.is_staff
})
else:
anonymous_perms = {
'id':
Group.objects.get(name='anonymous').id,
'title':
'anonymous',
'name':
'anonymous',
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype)
}
# Let's make sure we don't lose control over the resource
if not any([
_u.get('id', None) == self._resource.owner.id
for _u in user_perms
]):
user_perms.append({
'id':
self._resource.owner.id,
'username':
self._resource.owner.username,
'first_name':
self._resource.owner.first_name,
'last_name':
self._resource.owner.last_name,
'avatar':
build_absolute_uri(avatar_url(self._resource.owner, 240)),
'permissions':
OWNER_RIGHTS,
'is_superuser':
self._resource.owner.is_superuser,
'is_staff':
self._resource.owner.is_staff
})
for user in get_user_model().objects.filter(is_superuser=True):
if not any([_u.get('id', None) == user.id for _u in user_perms]):
user_perms.append({
'id':
user.id,
'username':
user.username,
'first_name':
user.first_name,
'last_name':
user.last_name,
'avatar':
build_absolute_uri(avatar_url(user, 240)),
'permissions':
MANAGE_RIGHTS,
'is_superuser':
user.is_superuser,
'is_staff':
user.is_staff
})
for _k in self.groups:
_perms = self.groups[_k]
if isinstance(_k, str):
_k = Group.objects.get(name=_k)
if _k.name == 'anonymous':
anonymous_perms = {
'id':
_k.id,
'title':
'anonymous',
'name':
'anonymous',
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype)
}
elif hasattr(_k, 'groupprofile'):
group = _Group(_k.id, _k.groupprofile.title, _k.name,
_k.groupprofile.logo_url)
if _k.name == groups_settings.REGISTERED_MEMBERS_GROUP_NAME:
contributors_perms = {
'id':
group.id,
'title':
group.title,
'name':
group.name,
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype)
}
else:
organization_perms.append({
'id':
group.id,
'title':
group.title,
'name':
group.name,
'logo':
group.logo,
'permissions':
_to_compact_perms(_perms, self._resource.resource_type,
self._resource.subtype)
})
if anonymous_perms:
group_perms.append(anonymous_perms)
else:
anonymous_group = Group.objects.get(name='anonymous')
group_perms.append({
'id':
anonymous_group.id,
'title':
'anonymous',
'name':
'anonymous',
'permissions':
_to_compact_perms(
get_group_perms(anonymous_group, self._resource),
self._resource.resource_type, self._resource.subtype)
})
if contributors_perms:
group_perms.append(contributors_perms)
elif Group.objects.filter(
name=groups_settings.REGISTERED_MEMBERS_GROUP_NAME).exists():
contributors_group = Group.objects.get(
name=groups_settings.REGISTERED_MEMBERS_GROUP_NAME)
group_perms.append({
'id':
contributors_group.id,
'title':
'Registered Members',
'name':
contributors_group.name,
'permissions':
_to_compact_perms(
get_group_perms(contributors_group, self._resource),
self._resource.resource_type, self._resource.subtype)
})
json['users'] = user_perms
json['organizations'] = organization_perms
json['groups'] = group_perms
return json.copy()
def dehydrate_avatar_100(self, bundle):
return avatar_url(bundle.obj, 100)
def dehydrate(self, bundle):
bundle.data['full_name'] = bundle.obj.user.full_name
bundle.data['profile_url'] = bundle.obj.user.get_absolute_url()
bundle.data['avatar_url'] = avatar_url(bundle.obj.user)
return bundle
def avatar_post_save(instance, sender, **kw):
MapstoryProfile.objects.filter(user_id=instance.user.id).update(
avatar_100=avatar_url(instance.user, 100))
