def get_by_user(self,
user,
querier,
page=1,
query_id=None,
all=False,
without_key=None):
"""
Obtiene las listas de un usuario
"""
if not user.is_authenticated():
return []
if user is None or querier is None:
raise TypeError()
if user.id == querier.id:
if without_key is not None:
q = self._klass.gql(
'WHERE user = :1 AND active = True ORDER BY modified DESC',
user)
else:
q = self._klass.gql(
'WHERE user = :1 AND active = True ORDER BY modified DESC',
user)
else:
q = self._klass.gql(
'WHERE user = :1 AND active = True AND _vis = :2 ORDER BY modified DESC',
user, 'public')
if not all:
from georemindme.paging import PagedQuery
p = PagedQuery(q, id=query_id)
lists = p.fetch_page(page)
prefetch_refprops(lists, self._klass.user)
return [p.id, lists]
else:
return q.run()
def get_by_tag_querier(self, tagInstance, querier, page=1, query_id=None):
from georemindme.paging import PagedQuery
if not isinstance(querier, User) and not isinstance(
querier, AnonymousUser):
raise TypeError()
from geotags.models import Tag
if not isinstance(tagInstance, Tag):
raise TypeError
lists = self._klass.all().filter('_tags_list =', tagInstance.key())
p = PagedQuery(lists, id=query_id)
return_list = []
lists_page = p.fetch_page(page)
for list in lists_page:
if list.__class__.user.get_value_for_datastore(
list) == querier.key():
return_list.append(list)
elif hasattr(list, '_vis'):
if list._is_public():
return_list.append(list)
elif list._is_shared() and list.user_invited(querier):
return_list.append(list)
if len(return_list) != 0:
prefetch_refprops(return_list, self._klass.user)
return [p.id, return_list]
return None
def get_by_user(self, user, querier, page=1, query_id=None, all=False, without_key=None):
"""
Obtiene las listas de un usuario
"""
if not user.is_authenticated():
return []
if user is None or querier is None:
raise TypeError()
if user.id == querier.id:
if without_key is not None:
q = self._klass.gql("WHERE user = :1 AND active = True ORDER BY modified DESC", user)
else:
q = self._klass.gql("WHERE user = :1 AND active = True ORDER BY modified DESC", user)
else:
q = self._klass.gql(
"WHERE user = :1 AND active = True AND _vis = :2 ORDER BY modified DESC", user, "public"
)
if not all:
from georemindme.paging import PagedQuery
p = PagedQuery(q, id=query_id)
lists = p.fetch_page(page)
prefetch_refprops(lists, self._klass.user)
return [p.id, lists]
else:
return q.run()
def get_by_tag_querier(self, tagInstance, querier, page=1, query_id=None):
from georemindme.paging import PagedQuery
if not isinstance(querier, User) and not isinstance(querier, AnonymousUser):
raise TypeError()
from geotags.models import Tag
if not isinstance(tagInstance, Tag):
raise TypeError
lists = self._klass.all().filter("_tags_list =", tagInstance.key())
p = PagedQuery(lists, id=query_id)
return_list = []
lists_page = p.fetch_page(page)
for list in lists_page:
if list.__class__.user.get_value_for_datastore(list) == querier.key():
return_list.append(list)
elif hasattr(list, "_vis"):
if list._is_public():
return_list.append(list)
elif list._is_shared() and list.user_invited(querier):
return_list.append(list)
if len(return_list) != 0:
prefetch_refprops(return_list, self._klass.user)
return [p.id, return_list]
return None
def search(self, word, page=1, query_id = None):
q = self._klass.all().search(word).order('-modified')
p = PagedQuery(q, id = query_id)
from georemindme.funcs import prefetch_refprops
pois = p.fetch_page(page)
pois = prefetch_refprops(pois, self._klass.user)
return [p.id, pois]
def search(self, word, page=1, query_id=None):
q = self._klass.all().search(word).order('-modified')
p = PagedQuery(q, id=query_id)
from georemindme.funcs import prefetch_refprops
pois = p.fetch_page(page)
pois = prefetch_refprops(pois, self._klass.user)
return [p.id, pois]
def get_by_tag_querier(self, tagInstance, querier, page=1, query_id=None):
if querier is None:
raise TypeError()
from geotags.models import Tag
if not isinstance(tagInstance, Tag):
raise TypeError
events = self._klass.all().filter('_tags_list =', tagInstance.key())
p = PagedQuery(events, id=query_id)
events_lists = []
from georemindme.funcs import prefetch_refprops
events = p.fetch_page(page)
for event in events:
if event.__class__.user.get_value_for_datastore(
event) == querier.key():
events_lists.append(event)
elif hasattr(event, '_vis'):
if event._is_public():
events_lists.append(event)
elif event._is_shared() and event.user_invited(querier):
events_lists.append(event)
if len(events_lists) != 0:
events_lists = prefetch_refprops(events_lists, self._klass.user,
self._klass.poi)
return [p.id, events_lists], p.page_count()
return None, 0
def get_all_public(self, query_id=None, page=1):
"""
Devuelve todas las listas publicas ¡PAGINADA!
:param page: numero de pagina a mostrar
:type param: int
:param query_id: identificador de busqueda
:type query_id: int
"""
q = self._klass.all().filter("_vis =", "public").filter("active =", True).order("-modified")
from georemindme.paging import PagedQuery
p = PagedQuery(q, id=query_id)
lists = p.fetch_page(page)
prefetch_refprops(lists, self._klass.user)
return [p.id, lists]
def get_all_public(self, query_id=None, page=1):
'''
Devuelve todas las listas publicas ¡PAGINADA!
:param page: numero de pagina a mostrar
:type param: int
:param query_id: identificador de busqueda
:type query_id: int
'''
q = self._klass.all().filter('_vis =',
'public').filter('active =',
True).order('-modified')
from georemindme.paging import PagedQuery
p = PagedQuery(q, id=query_id)
lists = p.fetch_page(page)
prefetch_refprops(lists, self._klass.user)
return [p.id, lists]
def get_by_suggestion(self, suggestion, querier):
if not isinstance(querier, User) and not isinstance(querier, AnonymousUser):
raise TypeError()
lists = self._klass.all().filter("keys =", suggestion.key()).filter("active =", True)
lists_loaded = []
for list in lists:
if not querier.is_authenticated():
if list._is_public():
lists_loaded.append(list)
else:
if list.__class__.user.get_value_for_datastore(list) == querier.key():
lists_loaded.append(list)
elif list._is_public():
lists_loaded.append(list)
elif list._is_shared() and list.user_invited(querier):
lists_loaded.append(list)
if len(lists_loaded) != 0:
prefetch_refprops(lists_loaded, self._klass.user)
return lists_loaded
return []
def get_by_business_user(self, business, user, page=1, query_id=None):
if not isinstance(user, User):
raise AttributeError()
if not isinstance(business, Business):
raise AttributeError()
q = self._klass.gql('WHERE business = :1 AND user = :2 ORDER BY created DESC', business, user)
p = PagedQuery(q, id = query_id)
from georemindme.funcs import prefetch_refprops
pois = p.fetch_page(page)
pois = prefetch_refprops(pois, self._klass.user, self._klass.business)
return [p.id, pois]
def get_by_user(self, user, page=1, query_id=None):
'''
Obtiene una lista con todos los Eventos
de un usuario
'''
if not isinstance(user, User):
raise TypeError()
q = self._klass.gql('WHERE user = :1 ORDER BY modified DESC', user)
p = PagedQuery(q, id=query_id)
from georemindme.funcs import prefetch_refprops
events = p.fetch_page(page)
events = prefetch_refprops(events, self._klass.user, self._klass.poi)
return [p.id, events, p.page_count()]
def get_by_business_user(self, business, user, page=1, query_id=None):
if not isinstance(user, User):
raise AttributeError()
if not isinstance(business, Business):
raise AttributeError()
q = self._klass.gql(
'WHERE business = :1 AND user = :2 ORDER BY created DESC',
business, user)
p = PagedQuery(q, id=query_id)
from georemindme.funcs import prefetch_refprops
pois = p.fetch_page(page)
pois = prefetch_refprops(pois, self._klass.user, self._klass.business)
return [p.id, pois]
def get_by_suggestion(self, suggestion, querier):
if not isinstance(querier, User) and not isinstance(
querier, AnonymousUser):
raise TypeError()
lists = self._klass.all().filter('keys =', suggestion.key()).filter(
'active =', True)
lists_loaded = []
for list in lists:
if not querier.is_authenticated():
if list._is_public():
lists_loaded.append(list)
else:
if list.__class__.user.get_value_for_datastore(
list) == querier.key():
lists_loaded.append(list)
elif list._is_public():
lists_loaded.append(list)
elif list._is_shared() and list.user_invited(querier):
lists_loaded.append(list)
if len(lists_loaded) != 0:
prefetch_refprops(lists_loaded, self._klass.user)
return lists_loaded
return []
def load_suggestions_async(suggestions):
suggestions = suggestions.get_result()
from georemindme.funcs import prefetch_refprops
from geoalert.models import Suggestion
suggestions = prefetch_refprops(suggestions, Suggestion.user, Suggestion.poi)
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())
}
)
return suggestions_loaded
def get_by_tag_owner(self, tagInstance, owner, page=1, query_id=None):
if not isinstance(owner, User):
raise TypeError()
from geotags.models import Tag
if not isinstance(tagInstance, Tag):
raise TypeError
events = self._klass.all().filter('_tags_list =',
tagInstance.key()).filter(
'user =', owner)
p = PagedQuery(events, id=query_id)
from georemindme.funcs import prefetch_refprops
events = p.fetch_page(page)
events = prefetch_refprops(events, self._klass.user, self._klass.poi)
return [p.id, events]
def get_nearest(self, location, radius = 5000):
if not isinstance(location, db.GeoPt):
location = db.GeoPt(location)
from mapsServices.fusiontable import ftclient, sqlbuilder
ftclient = ftclient.OAuthFTClient()
from django.conf import settings as __web_settings # parche hasta conseguir que se cachee variable global
query = ftclient.query(sqlbuilder.SQL().select(__web_settings.FUSIONTABLES['TABLE_PLACES'], cols=['place_id'],
condition = 'ST_INTERSECTS (location, CIRCLE(LATLNG (%s), %s))' % (location, radius)
)
)
results = query.splitlines()
del results[0] # quitar la primera linea con el nombre de la columna
places = [db.Key.from_path(self._klass.kind(), result) for result in results] # construir todas las keys para consultar en bach
places = db.get(places)
from georemindme.funcs import prefetch_refprops
places = prefetch_refprops(places, self._klass.user)
return places
def load_suggestions_async(suggestions):
suggestions = suggestions.get_result()
from georemindme.funcs import prefetch_refprops
from geoalert.models import Suggestion
suggestions = prefetch_refprops(suggestions, Suggestion.user,
Suggestion.poi)
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())
})
return suggestions_loaded
def load_suggestions_async(suggestions):
suggestions_loaded = [s for s in suggestions]
from georemindme.funcs import prefetch_refprops
suggestions = prefetch_refprops(suggestions_loaded, SuggestionModel.user, SuggestionModel.poi)
suggestions_loaded = []
for a in suggestions:
t = Suggestion(
name = a.name,
description = a.description,
poi_lat = a.poi.location.lat,
poi_lon = a.poi.location.lon,
poi_id = a.poi.id,
google_places_reference = a.poi.google_places_reference,
modified = int(mktime(a.modified.utctimetuple())),
created = int(mktime(a.created.utctimetuple())),
username = a.user.username,
id = a.id,
)
suggestions_loaded.append(t)
return suggestions_loaded
def get_nearest(self, location, radius=5000):
if not isinstance(location, db.GeoPt):
location = db.GeoPt(location)
from mapsServices.fusiontable import ftclient, sqlbuilder
ftclient = ftclient.OAuthFTClient()
from django.conf import settings as __web_settings # parche hasta conseguir que se cachee variable global
query = ftclient.query(sqlbuilder.SQL().select(
__web_settings.FUSIONTABLES['TABLE_PLACES'],
cols=['place_id'],
condition='ST_INTERSECTS (location, CIRCLE(LATLNG (%s), %s))' %
(location, radius)))
results = query.splitlines()
del results[0] # quitar la primera linea con el nombre de la columna
places = [
db.Key.from_path(self._klass.kind(), result) for result in results
] # construir todas las keys para consultar en bach
places = db.get(places)
from georemindme.funcs import prefetch_refprops
places = prefetch_refprops(places, self._klass.user)
return places
def get_by_user(self, user, querier, page=1, query_id=None):
"""
Obtiene una lista con todos los Eventos
de un usuario
"""
if not isinstance(user, User) or not isinstance(querier, User):
raise TypeError()
if user.id == querier.id:
q = self._klass.gql('WHERE user = :1 ORDER BY modified DESC', user)
else:
q = self._klass.gql(
'WHERE user = :1 AND _vis = :2 ORDER BY modified DESC', user,
'public')
p = PagedQuery(q, id=query_id)
suggestions = p.fetch_page(page)
from georemindme.funcs import prefetch_refprops
suggestions = prefetch_refprops(suggestions, self._klass.user,
self._klass.poi)
from geolist.models import ListSuggestion
for s in suggestions:
lists = ListSuggestion.objects.get_by_suggestion(s, querier)
setattr(s, 'lists', lists)
return [p.id, suggestions, p.page_count()]
def get_by_id(self, userid, query_id=None, querier=None):
'''
Obtiene la lista de ultimos timeline del usuario
:param userid: id del usuario (user.id)
:type userid: :class:`string`
:param page: numero de pagina a mostrar
:type param: int
:param query_id: identificador de busqueda
:type query_id: int
:returns: lista de tuplas de la forma [query_id, [(id, username, avatar)]]
'''
try:
userid = long(userid)
except:
return None
from geovote.models import Vote, Comment
from geoalert.models import Suggestion
from geolist.models import List
from models_acc import UserTimeline, UserTimelineSuggest
query = UserTimeline.all().filter(
'user ='******'-created')
if query_id is not None: # recuperamos los cursores anteriores
query = query.with_cursor(start_cursor=query_id)
timelines = query.fetch(10)
query_id = query.cursor()
from georemindme.funcs import prefetch_refprops
timelines = prefetch_refprops(timelines, UserTimeline.user,
UserTimeline.instance)
instances = _load_ref_instances(timelines)
if querier is None:
return [
query_id,
[{
'id':
timeline.id,
'created':
timeline.created,
'modified':
timeline.modified,
'msg':
timeline.msg,
'username':
timeline.user.username,
'msg_id':
timeline.msg_id,
'instance':
instances.get(
UserTimeline.instance.get_value_for_datastore(
timeline), timeline.instance),
'list':
instances.get(
UserTimelineSuggest.list_id.get_value_for_datastore(
timeline), timeline.list_id) if isinstance(
timeline, UserTimelineSuggest) else None,
'has_voted':
Vote.objects.user_has_voted(
db.Key.from_path(User.kind(), userid),
timeline.instance.key())
if timeline.instance is not None else None,
'vote_counter':
Vote.objects.get_vote_counter(timeline.instance.key())
if timeline.instance is not None else None,
'comments':
Comment.objects.get_by_instance(timeline.instance),
'is_private':
False
} for timeline in timelines]
]
elif querier.is_authenticated() and querier.are_friends(
db.Key.from_path(User.kind(), userid)):
return [
query_id,
[{
'id':
timeline.id,
'created':
timeline.created,
'modified':
timeline.modified,
'msg':
timeline.msg,
'username':
timeline.user.username,
'msg_id':
timeline.msg_id,
'instance':
instances.get(
UserTimeline.instance.get_value_for_datastore(
timeline), timeline.instance),
'list':
instances.get(
UserTimelineSuggest.list_id.get_value_for_datastore(
timeline), timeline.list_id) if isinstance(
timeline, UserTimelineSuggest) else None,
'has_voted':
Vote.objects.user_has_voted(querier,
timeline.instance.key())
if timeline.instance is not None else None,
'vote_counter':
Vote.objects.get_vote_counter(timeline.instance.key())
if timeline.instance is not None else None,
'comments':
Comment.objects.get_by_instance(timeline.instance,
querier=querier),
'user_follower':
timeline.instance.has_follower(querier)
if isinstance(timeline.instance, Suggestion)
and querier.is_authenticated() else None,
'is_private':
False,
} for timeline in timelines
if timeline._is_shared() or timeline._is_public()]
]
return [
query_id,
[{
'id':
timeline.id,
'created':
timeline.created,
'modified':
timeline.modified,
'msg':
timeline.msg,
'username':
timeline.user.username,
'msg_id':
timeline.msg_id,
'instance':
instances.get(
UserTimeline.instance.get_value_for_datastore(timeline),
timeline.instance),
'list':
instances.get(
UserTimelineSuggest.list_id.get_value_for_datastore(
timeline), timeline.list_id) if isinstance(
timeline, UserTimelineSuggest) else None,
'has_voted':
Vote.objects.user_has_voted(querier, timeline.instance.key())
if timeline.instance is not None
and querier.is_authenticated() else None,
'vote_counter':
Vote.objects.get_vote_counter(timeline.instance.key())
if timeline.instance is not None else None,
'comments':
Comment.objects.get_by_instance(timeline.instance,
querier=querier),
'user_follower':
timeline.instance.has_follower(querier)
if isinstance(timeline.instance, Suggestion)
and querier.is_authenticated() else None,
'is_private':
False,
} for timeline in timelines if timeline._is_public()]
]
place,
page=1,
query_id=None,
async=False,
querier=None):
if querier is None:
raise TypeError()
q = self._klass.all().filter('poi =', place.key())
p = PagedQuery(q, id=query_id)
if async:
return p.id, q.run()
else:
from geovote.models import Vote
from georemindme.funcs import prefetch_refprops
suggestions = p.fetch_page(page)
suggestions = prefetch_refprops(suggestions, Suggestion.user,
Suggestion.poi)
[
p.id,
[{
'instance':
suggestion,
'has_voted':
Vote.objects.user_has_voted(querier, suggestion.key()),
'vote_counter':
Vote.objects.get_vote_counter(suggestion.key())
} for suggestion in suggestions]
]
def get_by_id_user(self, id, user, querier):
'''
Obtiene el evento con ese id comprobando que
def get_activity_timeline(self, query_id=None):
from models_acc import UserTimelineSystem, UserTimeline, UserTimelineFollowersIndex, UserTimelineSuggest
from geovote.models import Comment, Vote
from geoalert.models import Event
from geolist.models import List
# definir las consultas
query_chrono = UserTimelineFollowersIndex.all().filter(
'followers =', self.key()).order('-created')
query_activity = UserTimelineSystem.all().filter(
'user ='******'visible =', True).order('-modified')
# recuperar cursores
if query_id is not None and len(query_id) >= 2:
cursor_chronology = query_id[0]
cursor_activity = query_id[1]
query_chrono = query_chrono.with_cursor(
start_cursor=cursor_chronology)
query_activity = query_activity.with_cursor(
start_cursor=cursor_activity)
else:
cursor_activity = None
cursor_chronology = None
# let's go!
timeline = []
timeline_chrono = []
activity_async = query_activity.run(
config=datastore_query.QueryOptions(limit=TIMELINE_PAGE_SIZE))
chrono_async = query_chrono.run(config=datastore_query.QueryOptions(
limit=TIMELINE_PAGE_SIZE))
_go_chrono = True
chrono = None
for activity_timeline in activity_async:
while _go_chrono:
if len(timeline) + len(timeline_chrono) >= TIMELINE_PAGE_SIZE:
_go_chrono = False
break
if chrono is None:
try:
chrono = chrono_async.next()
except:
_go_chrono = False
break
if chrono is not None and chrono.created > activity_timeline.modified:
timeline_chrono.append(chrono)
chrono = None
else:
break
timeline.append(activity_timeline)
if len(timeline) + len(timeline_chrono) >= TIMELINE_PAGE_SIZE:
break
# generar timeline
timeline_chrono = fetch_parents(timeline_chrono)
timeline = prefetch_refprops(timeline, UserTimeline.user)
timeline_chrono = prefetch_refprops(timeline_chrono,
UserTimeline.instance,
UserTimeline.user)
timeline.extend(timeline_chrono)
#seguimos cargando por lotes todas las referencias
from helpers_acc import _load_ref_instances
instances = _load_ref_instances(timeline)
timeline = [{
'id':
int(activity_timeline.id),
'created':
activity_timeline.created,
'modified':
activity_timeline.modified,
'msg':
activity_timeline.msg,
'username':
activity_timeline.user.username,
'msg_id':
activity_timeline.msg_id,
'instance':
instances.get(
UserTimeline.instance.get_value_for_datastore(
activity_timeline), activity_timeline.instance),
'has_voted':
Vote.objects.user_has_voted(self, activity_timeline.instance.key())
if activity_timeline.instance is not None else None,
'vote_counter':
Vote.objects.get_vote_counter(activity_timeline.instance.key())
if activity_timeline.instance is not None else None,
'comments':
Comment.objects.get_by_instance(activity_timeline.instance,
querier=self),
'list':
instances.get(
UserTimelineSuggest.list_id.get_value_for_datastore(
activity_timeline), activity_timeline.list_id)
if isinstance(activity_timeline, UserTimelineSuggest) else None,
'status':
activity_timeline.status
if hasattr(activity_timeline, 'status') else None,
'is_private':
True,
'user_follower':
instances.get(
UserTimeline.instance.get_value_for_datastore(
activity_timeline),
activity_timeline.instance).has_follower(self) if hasattr(
instances.get(
UserTimeline.instance.get_value_for_datastore(
activity_timeline), activity_timeline.instance),
'has_follower') else None,
} for activity_timeline in timeline]
from operator import itemgetter
timeline_sorted = sorted(timeline,
key=itemgetter('modified'),
reverse=True)
chronology = [[query_chrono.cursor(),
query_activity.cursor()], timeline_sorted]
return chronology
def get_by_id(self, userid, query_id = None, querier=None):
'''
Obtiene la lista de ultimos timeline del usuario
:param userid: id del usuario (user.id)
:type userid: :class:`string`
:param page: numero de pagina a mostrar
:type param: int
:param query_id: identificador de busqueda
:type query_id: int
:returns: lista de tuplas de la forma [query_id, [(id, username, avatar)]]
'''
try:
userid = long(userid)
except:
return None
from geovote.models import Vote, Comment
from geoalert.models import Suggestion
from geolist.models import List
from models_acc import UserTimeline, UserTimelineSuggest
query = UserTimeline.all().filter('user ='******'-created')
if query_id is not None: # recuperamos los cursores anteriores
query = query.with_cursor(start_cursor=query_id)
timelines = query.fetch(10)
query_id = query.cursor()
from georemindme.funcs import prefetch_refprops
timelines = prefetch_refprops(timelines, UserTimeline.user, UserTimeline.instance)
instances = _load_ref_instances(timelines)
if querier is None:
return [query_id, [{'id': timeline.id, 'created': timeline.created,
'modified': timeline.modified,
'msg': timeline.msg, 'username':timeline.user.username,
'msg_id': timeline.msg_id,
'instance': instances.get(UserTimeline.instance.get_value_for_datastore(timeline), timeline.instance),
'list': instances.get(UserTimelineSuggest.list_id.get_value_for_datastore(timeline), timeline.list_id)
if isinstance(timeline, UserTimelineSuggest) else None,
'has_voted': Vote.objects.user_has_voted(db.Key.from_path(User.kind(), userid), timeline.instance.key()) if timeline.instance is not None else None,
'vote_counter': Vote.objects.get_vote_counter(timeline.instance.key()) if timeline.instance is not None else None,
'comments': Comment.objects.get_by_instance(timeline.instance),
'is_private': False
}
for timeline in timelines]]
elif querier.is_authenticated() and querier.are_friends(db.Key.from_path(User.kind(), userid)):
return [query_id, [{'id': timeline.id, 'created': timeline.created,
'modified': timeline.modified,
'msg': timeline.msg, 'username':timeline.user.username,
'msg_id': timeline.msg_id,
'instance': instances.get(UserTimeline.instance.get_value_for_datastore(timeline), timeline.instance),
'list': instances.get(UserTimelineSuggest.list_id.get_value_for_datastore(timeline), timeline.list_id)
if isinstance(timeline, UserTimelineSuggest) else None,
'has_voted': Vote.objects.user_has_voted(querier, timeline.instance.key()) if timeline.instance is not None else None,
'vote_counter': Vote.objects.get_vote_counter(timeline.instance.key()) if timeline.instance is not None else None,
'comments': Comment.objects.get_by_instance(timeline.instance, querier=querier),
'user_follower': timeline.instance.has_follower(querier) if isinstance(timeline.instance, Suggestion) and querier.is_authenticated() else None,
'is_private': False,
}
for timeline in timelines if timeline._is_shared() or timeline._is_public()]]
return [query_id, [{'id': timeline.id, 'created': timeline.created,
'modified': timeline.modified,
'msg': timeline.msg, 'username':timeline.user.username,
'msg_id': timeline.msg_id,
'instance': instances.get(UserTimeline.instance.get_value_for_datastore(timeline), timeline.instance),
'list': instances.get(UserTimelineSuggest.list_id.get_value_for_datastore(timeline), timeline.list_id)
if isinstance(timeline, UserTimelineSuggest) else None,
'has_voted': Vote.objects.user_has_voted(querier, timeline.instance.key()) if timeline.instance is not None and querier.is_authenticated()else None,
'vote_counter': Vote.objects.get_vote_counter(timeline.instance.key()) if timeline.instance is not None else None,
'comments': Comment.objects.get_by_instance(timeline.instance, querier=querier),
'user_follower': timeline.instance.has_follower(querier) if isinstance(timeline.instance, Suggestion) and querier.is_authenticated() else None,
'is_private': False,
}
for timeline in timelines if timeline._is_public()]]
def get_nearest(self, location, radius=5000, querier=None):
if not isinstance(location, db.GeoPt):
location = db.GeoPt(location)
import memcache
client = memcache.mem.Client()
if querier is not None and querier.is_authenticated():
sugs = client.get('%ssug_nearest%s,%s_%s' % (
memcache.version,
location.lat,
location.lon,
querier.username,
))
else:
sugs = client.get('%ssug_nearest%s,%s' %
(memcache.version, location.lat, location.lon))
if sugs is None:
from mapsServices.fusiontable import ftclient, sqlbuilder
ftclient = ftclient.OAuthFTClient()
from django.conf import settings as __web_settings # parche hasta conseguir que se cachee variable global
query = ftclient.query(sqlbuilder.SQL().select(
__web_settings.FUSIONTABLES['TABLE_SUGGS'],
cols=['sug_id'],
condition=
'ST_INTERSECTS (location, CIRCLE(LATLNG (%s), %s)) ORDER BY relevance DESC LIMIT 50'
% (location, radius)))
results = query.splitlines()
if len(results) == 1:
return []
del results[
0] # quitar la primera linea con el nombre de la columna
try:
sugs = [
db.Key.from_path(self._klass.kind(), int(result))
for result in results
] # construir todas las keys para consultar en bach
except:
return []
sugs = db.get(sugs)
sugs = filter(None, sugs)
if querier is not None and querier.is_authenticated():
sugs = filter(
lambda x: x.__class__.user.get_value_for_datastore(x) !=
querier.key(), sugs)
from georemindme.funcs import prefetch_refprops
prefetch_refprops(sugs, Suggestion.user, Suggestion.poi)
sugs = sorted(sugs,
key=lambda x: x._calc_relevance(),
reverse=True)
sugs = [{
'id': sug.key().id(),
'slug': sug.slug,
'username': sug.user.username,
'name': sug.name,
'address': sug.poi.address,
'description': sug.description,
'poi': {
'lat': sug.poi.location.lat,
'lon': sug.poi.location.lon,
'id': sug.poi.id,
},
'created': sug.created,
'modified': sug.modified,
} for sug in sugs]
if querier is not None and querier.is_authenticated():
client.set(
'%ssug_nearest%s,%s_%s' % (
memcache.version,
location.lat,
location.lon,
querier.username,
), sugs, 112)
else:
client.set(
'%ssug_nearest%s,%s' %
(memcache.version, location.lat, location.lon), sugs, 112)
# FIXME : DEBERIA USARSE CAS EN VEZ DE SET EN MEMCACHE
return sugs
def get_activity_timeline(self, query_id=None):
from models_acc import UserTimelineSystem, UserTimeline, UserTimelineFollowersIndex, UserTimelineSuggest
from geovote.models import Comment, Vote
from geoalert.models import Event
from geolist.models import List
# definir las consultas
query_chrono = UserTimelineFollowersIndex.all().filter('followers =', self.key()).order('-created')
query_activity = UserTimelineSystem.all().filter('user ='******'visible =', True).order('-modified')
# recuperar cursores
if query_id is not None and len(query_id)>=2:
cursor_chronology = query_id[0]
cursor_activity = query_id[1]
query_chrono = query_chrono.with_cursor(start_cursor=cursor_chronology)
query_activity = query_activity.with_cursor(start_cursor=cursor_activity)
else:
cursor_activity = None
cursor_chronology = None
# let's go!
timeline = []
timeline_chrono = []
activity_async = query_activity.run(config=datastore_query.QueryOptions(limit=TIMELINE_PAGE_SIZE))
chrono_async = query_chrono.run(config=datastore_query.QueryOptions(limit=TIMELINE_PAGE_SIZE))
_go_chrono = True
chrono = None
for activity_timeline in activity_async:
while _go_chrono:
if len(timeline) + len(timeline_chrono) >= TIMELINE_PAGE_SIZE:
_go_chrono = False
break
if chrono is None:
try:
chrono = chrono_async.next()
except:
_go_chrono = False
break
if chrono is not None and chrono.created > activity_timeline.modified:
timeline_chrono.append(chrono)
chrono = None
else:
break
timeline.append(activity_timeline)
if len(timeline) + len(timeline_chrono) >= TIMELINE_PAGE_SIZE:
break
# generar timeline
timeline_chrono = fetch_parents(timeline_chrono)
timeline = prefetch_refprops(timeline, UserTimeline.user)
timeline_chrono = prefetch_refprops(timeline_chrono, UserTimeline.instance, UserTimeline.user)
timeline.extend(timeline_chrono)
#seguimos cargando por lotes todas las referencias
from helpers_acc import _load_ref_instances
instances = _load_ref_instances(timeline)
timeline = [{
'id': int(activity_timeline.id),
'created': activity_timeline.created,
'modified': activity_timeline.modified,
'msg': activity_timeline.msg,
'username': activity_timeline.user.username,
'msg_id': activity_timeline.msg_id,
'instance': instances.get(UserTimeline.instance.get_value_for_datastore(activity_timeline), activity_timeline.instance),
'has_voted': Vote.objects.user_has_voted(self, activity_timeline.instance.key()) if activity_timeline.instance is not None else None,
'vote_counter': Vote.objects.get_vote_counter(activity_timeline.instance.key()) if activity_timeline.instance is not None else None,
'comments': Comment.objects.get_by_instance(activity_timeline.instance, querier=self),
'list': instances.get(UserTimelineSuggest.list_id.get_value_for_datastore(activity_timeline), activity_timeline.list_id)
if isinstance(activity_timeline, UserTimelineSuggest) else None,
'status': activity_timeline.status if hasattr(activity_timeline, 'status') else None,
'is_private': True,
'user_follower': instances.get(UserTimeline.instance.get_value_for_datastore(activity_timeline), activity_timeline.instance).has_follower(self)
if hasattr(instances.get(UserTimeline.instance.get_value_for_datastore(activity_timeline), activity_timeline.instance), 'has_follower')
else None,
} for activity_timeline in timeline]
from operator import itemgetter
timeline_sorted = sorted(timeline, key=itemgetter('modified'), reverse=True)
chronology = [[query_chrono.cursor(), query_activity.cursor()], timeline_sorted]
return chronology
