def _load_ref_instances(timelines):
"""
resuelve todas las referencias por lotes a las que estan apuntando el timeline
Para luego construir el diccionario a devolver:
'instance': instances.get(UserTimeline.instance.get_value_for_datastore(timeline), timeline.instance),
'list': instances.get(UserTimelineSuggest.list.get_value_for_datastore(timeline), timeline.list)
if isinstance(timeline, UserTimelifrom geovote.models import Vote, CommentneSuggest) else None,
"""
from georemindme import model_plus
from models_acc import UserTimelineSuggest, UserTimeline
from geovote.models import Comment, Vote
from geolist.models import List, ListSuggestion
from geoalert.models import Event, Suggestion
# cargo todas las referencias en instance
instances = [t.instance for t in timelines if not isinstance(t.instance, User)]
instances.extend(model_plus.prefetch([i for i in instances if isinstance(i, Comment) or isinstance(i, Vote)],
Comment.instance)
)
instances.extend([i.instance for i in instances if isinstance(i, Comment) or isinstance(i, Vote)])
instances.extend(model_plus.prefetch(instances, UserTimeline.user,
))
instances = filter(None, instances)
# devuelvo en un diccionario para luego crear el diccionario resultante
instances = dict((i.key(), i) for i in instances)
return instances
def load_comments_from_async(self, query_id, comments_async, querier):
if querier is None:
raise TypeError
comments_objects = []
for comment in comments_async:
comments_objects.append(comment)
comments_objects = model_plus.prefetch(comments_objects, Comment.user)
return [
query_id,
[{
'id':
comment.id,
'created':
comment.created,
'modified':
comment.modified,
'msg':
comment.msg,
'username':
comment.user.username,
'has_voted':
Vote.objects.user_has_voted(querier, comment.key())
if querier is not None else None,
'vote_counter':
comment.votes,
} for comment in comments_objects]
]
def get_by_last_created(self, limit, querier, user=None):
if user is None:
events = self._klass.all().order('-created').fetch(limit)
else:
events = self._klass.all().filter(
'user ='******'-created').fetch(limit)
if events is None:
return None
event_to_response = []
for e in events:
if e._is_public():
event_to_response.append(e)
elif e.__class__.user.get_value_for_datastore(e) == querier.key():
event_to_response.append(e)
elif e._is_shared() and e.user_invited(querier):
event_to_response.append(e)
model_plus.prefetch(event_to_response, self._klass.user)
return event_to_response
def suggestion_profile(request, slug, template='generic/suggestionprofile.html'):
"""Devuelve el perfil de una sugerencia, comprueba la visibilidad de una funcion
:param id: identificador de la sugerencia
:type id: :class:`ìnteger`
"""
suggestion = Suggestion.objects.get_by_slug_querier(slug, querier=request.user)
if suggestion is None:
raise Http404
from geovote.models import Vote, Comment
from geolist.models import ListSuggestion
from georemindme.funcs import single_prefetch_refprops, prefetch_refList, prefetch_refprops
if 'print' in request.GET:
suggestion = single_prefetch_refprops(suggestion, Suggestion.user, Suggestion.poi)
vote_counter = Vote.objects.get_vote_counter(suggestion.key())
top_comments = Comment.objects.get_top_voted(suggestion, request.user)
return render_to_response('print/suggestionprofile.html',
{'suggestion': suggestion,
'vote_counter': vote_counter,
'top_comments': top_comments,
},
context_instance=RequestContext(request)
)
from geovote.api import get_comments
lists = ListSuggestion.objects.get_by_user(user=request.user, querier=request.user, all=True)
query_id, comments_async = get_comments(request.user, suggestion, async=True)
suggestion.prefetch(Suggestion.user, Suggestion.poi)
has_voted = Vote.objects.user_has_voted(request.user, suggestion.key())
vote_counter = Vote.objects.get_vote_counter(suggestion.key())
user_follower = suggestion.has_follower(request.user)
top_comments = Comment.objects.get_top_voted(suggestion, request.user)
in_lists = ListSuggestion.objects.get_by_suggestion(suggestion, request.user)
# construir un diccionario con todas las keys resueltas y usuarios
in_lists = [l.to_dict(resolve=False) for l in in_lists]
# listas del usuario
lists = [l for l in lists if not suggestion.key() in l.keys]
lists = model_plus.prefetch(lists, ListSuggestion.user)
lists = [l.to_dict(resolve=False) for l in lists]
# construir un diccionario con todas las keys resueltas y usuarios
if not request.user.is_authenticated():
pos = template.rfind('.html')
template = template[:pos] + '_anonymous' + template[pos:]
return render_to_response(template, {
'suggestion': suggestion,
'comments': Comment.objects.load_comments_from_async(query_id, comments_async, request.user),
'has_voted': has_voted,
'in_lists': in_lists,
'lists': lists,
'vote_counter': vote_counter,
'user_follower': user_follower,
'top_comments': top_comments,
},
context_instance=RequestContext(request))
def load_suggestions_async(suggestions):
suggestions_loaded = []
for suggestion in suggestions:
suggestions_loaded.append({
'instance': suggestion,
'has_voted': Vote.objects.user_has_voted(request.user, suggestion.key()) if request.user.is_authenticated() else False,
'vote_counter': Vote.objects.get_vote_counter(suggestion.key())
}
)
suggestions = model_plus.prefetch([s['instance'] for s in suggestions_loaded], Suggestion.user, Suggestion.poi)
return suggestions_loaded
def get_suggestions_dict(querier):
from models_indexes import SuggestionFollowersIndex
indexes = SuggestionFollowersIndex.all(keys_only=True).filter('keys =', querier.key()).order('-created').run()
suggs = model_plus.fetch_parentsKeys([s for s in indexes])
if isinstance(suggs, list) and any(suggs):
suggestions = []
for s in suggs: # convertir entidades
setattr(s, 'lists', [])
suggestions.append(s)
suggestions = model_plus.prefetch(suggestions, Suggestion.user, Suggestion.poi)
return suggestions
return []
def _load_ref_instances(timelines):
"""
resuelve todas las referencias por lotes a las que estan apuntando el timeline
Para luego construir el diccionario a devolver:
'instance': instances.get(UserTimeline.instance.get_value_for_datastore(timeline), timeline.instance),
'list': instances.get(UserTimelineSuggest.list.get_value_for_datastore(timeline), timeline.list)
if isinstance(timeline, UserTimelifrom geovote.models import Vote, CommentneSuggest) else None,
"""
from georemindme import model_plus
from models_acc import UserTimelineSuggest, UserTimeline
from geovote.models import Comment, Vote
from geolist.models import List, ListSuggestion
from geoalert.models import Event, Suggestion
# cargo todas las referencias en instance
instances = [
t.instance for t in timelines if not isinstance(t.instance, User)
]
instances.extend(
model_plus.prefetch([
i for i in instances
if isinstance(i, Comment) or isinstance(i, Vote)
], Comment.instance))
instances.extend([
i.instance for i in instances
if isinstance(i, Comment) or isinstance(i, Vote)
])
instances.extend(model_plus.prefetch(
instances,
UserTimeline.user,
))
instances = filter(None, instances)
# devuelvo en un diccionario para luego crear el diccionario resultante
instances = dict((i.key(), i) for i in instances)
return instances
def load_suggestions_async(suggestions):
suggestions_loaded = []
for suggestion in suggestions:
suggestions_loaded.append({
'instance':
suggestion,
'has_voted':
Vote.objects.user_has_voted(request.user, suggestion.key())
if request.user.is_authenticated() else False,
'vote_counter':
Vote.objects.get_vote_counter(suggestion.key())
})
suggestions = model_plus.prefetch(
[s['instance'] for s in suggestions_loaded], Suggestion.user,
Suggestion.poi)
return suggestions_loaded
def load_comments_from_async(self, query_id, comments_async, querier):
if querier is None:
raise TypeError
comments_objects = []
for comment in comments_async:
comments_objects.append(comment)
comments_objects = model_plus.prefetch(comments_objects, Comment.user)
return [query_id, [{'id': comment.id,
'created': comment.created,
'modified': comment.modified,
'msg': comment.msg,
'username': comment.user.username,
'has_voted': Vote.objects.user_has_voted(querier, comment.key()) if querier is not None else None,
'vote_counter': comment.votes,
} for comment in comments_objects]
]
def prefetch_timeline(entities):
# from http://blog.notdot.net/2010/01/ReferenceProperty-prefetching-in-App-Engine
"""
Carga todos los timelines apuntados por _Notifications
de una sola vez
"""
from models_acc import UserTimelineSuggest, UserTimeline
from geovote.models import Comment, Vote
from geolist.models import List, ListSuggestion
from geoalert.models import Event, Suggestion
ref_keys = [x['timeline'] for x in entities]
timelines = model_plus.get(set(ref_keys))
timelines = filter(None, timelines)
# precargar las referencias
timelines = model_plus.prefetch(timelines, UserTimeline.instance, UserTimeline.user)
from helpers_acc import _load_ref_instances
return timelines, _load_ref_instances(timelines)
def prefetch_timeline(entities):
# from http://blog.notdot.net/2010/01/ReferenceProperty-prefetching-in-App-Engine
"""
Carga todos los timelines apuntados por _Notifications
de una sola vez
"""
from models_acc import UserTimelineSuggest, UserTimeline
from geovote.models import Comment, Vote
from geolist.models import List, ListSuggestion
from geoalert.models import Event, Suggestion
ref_keys = [x['timeline'] for x in entities]
timelines = model_plus.get(set(ref_keys))
timelines = filter(None, timelines)
# precargar las referencias
timelines = model_plus.prefetch(timelines, UserTimeline.instance,
UserTimeline.user)
from helpers_acc import _load_ref_instances
return timelines, _load_ref_instances(timelines)
def suggestion_profile(request,
slug,
template='generic/suggestionprofile.html'):
"""Devuelve el perfil de una sugerencia, comprueba la visibilidad de una funcion
:param id: identificador de la sugerencia
:type id: :class:`ìnteger`
"""
suggestion = Suggestion.objects.get_by_slug_querier(slug,
querier=request.user)
if suggestion is None:
raise Http404
from geovote.models import Vote, Comment
from geolist.models import ListSuggestion
from georemindme.funcs import single_prefetch_refprops, prefetch_refList, prefetch_refprops
if 'print' in request.GET:
suggestion = single_prefetch_refprops(suggestion, Suggestion.user,
Suggestion.poi)
vote_counter = Vote.objects.get_vote_counter(suggestion.key())
top_comments = Comment.objects.get_top_voted(suggestion, request.user)
return render_to_response('print/suggestionprofile.html', {
'suggestion': suggestion,
'vote_counter': vote_counter,
'top_comments': top_comments,
},
context_instance=RequestContext(request))
from geovote.api import get_comments
lists = ListSuggestion.objects.get_by_user(user=request.user,
querier=request.user,
all=True)
query_id, comments_async = get_comments(request.user,
suggestion,
async=True)
suggestion.prefetch(Suggestion.user, Suggestion.poi)
has_voted = Vote.objects.user_has_voted(request.user, suggestion.key())
vote_counter = Vote.objects.get_vote_counter(suggestion.key())
user_follower = suggestion.has_follower(request.user)
top_comments = Comment.objects.get_top_voted(suggestion, request.user)
in_lists = ListSuggestion.objects.get_by_suggestion(
suggestion, request.user)
# construir un diccionario con todas las keys resueltas y usuarios
in_lists = [l.to_dict(resolve=False) for l in in_lists]
# listas del usuario
lists = [l for l in lists if not suggestion.key() in l.keys]
lists = model_plus.prefetch(lists, ListSuggestion.user)
lists = [l.to_dict(resolve=False) for l in lists]
# construir un diccionario con todas las keys resueltas y usuarios
if not request.user.is_authenticated():
pos = template.rfind('.html')
template = template[:pos] + '_anonymous' + template[pos:]
return render_to_response(template, {
'suggestion':
suggestion,
'comments':
Comment.objects.load_comments_from_async(query_id, comments_async,
request.user),
'has_voted':
has_voted,
'in_lists':
in_lists,
'lists':
lists,
'vote_counter':
vote_counter,
'user_follower':
user_follower,
'top_comments':
top_comments,
},
context_instance=RequestContext(request))
