def get_followings(self, userid=None, username=None, page=1, query_id=None):
"""Obtiene la lista de personas a las que sigue el usuario
:param userid: id del usuario (user.id)
:type userid: :class:`string`
:param username: nombre del usuario (user.username)
:type username: :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)]]
:raises: AttributeError
"""
if username is not None:
userkey = self.get_by_username(username, keys_only=True)
elif userid is not None:
userkey = db.Key.from_path(User.kind(), userid)
else:
raise AttributeError()
from georemindme.paging import PagedQuery
from models_acc import UserFollowingIndex
followings = UserFollowingIndex.all().ancestor(userkey).order("-created")
p = PagedQuery(followings, id=query_id)
users = [index.following for index in p.fetch_page(page)] # devuelve una lista anidada con otra
users = db.get([item for sublist in users for item in sublist])
return [p.id, [{"id": u.id, "username": u.username, "profile": u.profile} for u in users]]
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_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_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):
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_by_user(self, user, query_id = None, page=1, querier=None):
"""
Obtiene una lista con todos los comentarios hechos por un usuario
:param user: usuario a buscar
:type user: :class:`geouser.models.User`
:param query_id: identificador de la busqueda paginada
:type query_id: :class:`long`
:param page: pagina a buscar
:type page: :class:`integer`
:returns: [query_id, [:class:`geovote.models.Comment`]]
"""
if querier is not None and not isinstance(querier, User):
raise TypeError
from georemindme.paging import PagedQuery
from google.appengine.api import datastore
q = datastore.Query('Comment', {'user ='******'deleted =': False})
q.Order(('created', datastore.Query.DESCENDING))
p = PagedQuery(q, id = query_id, page_size=7)
comments = p.fetch_page(page)
from georemindme.funcs import prefetch_refpropsEntity
prefetch = prefetch_refpropsEntity(comments, 'user', 'instance')
return [p.id, [
{'id': comment.key().id(),
'username': prefetch[comment['user']].username,
'has_voted': Vote.objects.user_has_voted(querier, comment.key()) if querier is not None else None,
'vote_counter': comment['votes'],
'instance': prefetch[comment['instance']],
'msg': comment['msg'],
'created': comment['created'],
} for comment in comments]
]
def get_by_user_done(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 AND has = "done:T" ORDER BY modified DESC', user)
p = PagedQuery(q, id=query_id)
return [p.id, p.fetch_page(page)]
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_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_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_user(self, user, query_id=None, page=1, querier=None):
"""
Obtiene una lista con todos los comentarios hechos por un usuario
:param user: usuario a buscar
:type user: :class:`geouser.models.User`
:param query_id: identificador de la busqueda paginada
:type query_id: :class:`long`
:param page: pagina a buscar
:type page: :class:`integer`
:returns: [query_id, [:class:`geovote.models.Comment`]]
"""
if querier is not None and not isinstance(querier, User):
raise TypeError
from georemindme.paging import PagedQuery
from google.appengine.api import datastore
q = datastore.Query('Comment', {
'user ='******'deleted =': False
})
q.Order(('created', datastore.Query.DESCENDING))
p = PagedQuery(q, id=query_id, page_size=7)
comments = p.fetch_page(page)
from georemindme.funcs import prefetch_refpropsEntity
prefetch = prefetch_refpropsEntity(comments, 'user', 'instance')
return [
p.id,
[{
'id':
comment.key().id(),
'username':
prefetch[comment['user']].username,
'has_voted':
Vote.objects.user_has_voted(querier, comment.key())
if querier is not None else None,
'vote_counter':
comment['votes'],
'instance':
prefetch[comment['instance']],
'msg':
comment['msg'],
'created':
comment['created'],
} for comment in comments]
]
def get_followers(self, userid=None, username=None, page=1, query_id=None):
"""Obtiene la lista de followers de un usuario
:param userid: id del usuario (user.id)
:type userid: :class:`string`
:param username: nombre del usuario (user.username)
:type username: :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)]]
:raises: AttributeError
"""
if username is not None:
userkey = self.get_by_username(username, keys_only=True)
elif userid is not None:
userkey = db.Key.from_path(User.kind(), userid)
else:
raise AttributeError()
from georemindme.paging import PagedQuery
from models_acc import UserFollowingIndex
followers = UserFollowingIndex.all().filter("following =", userkey).order("-created")
p = PagedQuery(followers, id=query_id)
from georemindme.funcs import fetch_parents
users = fetch_parents(p.fetch_page(page))
return [
p.id,
[
{
"id": u.id,
"username": u.username,
"is_following": u.has_follower(userkey=userkey),
"profile": u.profile,
}
for u in users
],
]
def get_followings(self,
userid=None,
username=None,
page=1,
query_id=None):
"""Obtiene la lista de personas a las que sigue el usuario
:param userid: id del usuario (user.id)
:type userid: :class:`string`
:param username: nombre del usuario (user.username)
:type username: :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)]]
:raises: AttributeError
"""
if username is not None:
userkey = self.get_by_username(username, keys_only=True)
elif userid is not None:
userkey = db.Key.from_path(User.kind(), userid)
else:
raise AttributeError()
from georemindme.paging import PagedQuery
from models_acc import UserFollowingIndex
followings = UserFollowingIndex.all().ancestor(userkey).order(
'-created')
p = PagedQuery(followings, id=query_id)
users = [index.following for index in p.fetch_page(page)
] # devuelve una lista anidada con otra
users = db.get([item for sublist in users for item in sublist])
return [
p.id,
[{
'id': u.id,
'username': u.username,
'profile': u.profile
} for u in users]
]
def get_followers(self, userid=None, username=None, page=1, query_id=None):
"""Obtiene la lista de followers de un usuario
:param userid: id del usuario (user.id)
:type userid: :class:`string`
:param username: nombre del usuario (user.username)
:type username: :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)]]
:raises: AttributeError
"""
if username is not None:
userkey = self.get_by_username(username, keys_only=True)
elif userid is not None:
userkey = db.Key.from_path(User.kind(), userid)
else:
raise AttributeError()
from georemindme.paging import PagedQuery
from models_acc import UserFollowingIndex
followers = UserFollowingIndex.all().filter('following =',
userkey).order('-created')
p = PagedQuery(followers, id=query_id)
from georemindme.funcs import fetch_parents
users = fetch_parents(p.fetch_page(page))
return [
p.id,
[{
'id': u.id,
'username': u.username,
'is_following': u.has_follower(userkey=userkey),
'profile': u.profile
} for u in users]
]
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()]
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_place(self,
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()),
class CommentHelper(object):
""" Helper de la clase comentario """
def get_by_id(self, id):
try:
id = long(id)
except:
return None
comment = Comment.get_by_id(id)
if comment is not None:
if comment.deleted:
return None
if comment._is_public():
return comment
return None
def get_by_key(self, key):
"""
Obtiene el evento con ese key
"""
return Comment.get(key)
def get_by_user(self, user, query_id=None, page=1, querier=None):
"""
Obtiene una lista con todos los comentarios hechos por un usuario
:param user: usuario a buscar
:type user: :class:`geouser.models.User`
:param query_id: identificador de la busqueda paginada
:type query_id: :class:`long`
:param page: pagina a buscar
:type page: :class:`integer`
:returns: [query_id, [:class:`geovote.models.Comment`]]
"""
if querier is not None and not isinstance(querier, User):
raise TypeError
from georemindme.paging import PagedQuery
from google.appengine.api import datastore
q = datastore.Query('Comment', {
'user ='******'deleted =': False
})
q.Order(('created', datastore.Query.DESCENDING))
p = PagedQuery(q, id=query_id, page_size=7)
comments = p.fetch_page(page)
from georemindme.funcs import prefetch_refpropsEntity
prefetch = prefetch_refpropsEntity(comments, 'user', 'instance')
return [
p.id,
[{
'id':
comment.key().id(),
'username':
prefetch[comment['user']].username,
'has_voted':
Vote.objects.user_has_voted(querier, comment.key())
if querier is not None else None,
'vote_counter':
comment['votes'],
'instance':
prefetch[comment['instance']],
'msg':
comment['msg'],
'created':
comment['created'],
} for comment in comments]
]
def get_by_instance(self,
instance,
query_id=None,
page=1,
querier=None,
async=False):
"""
Obtiene una lista con todos los comentarios hechos en una instancia
:param instance: objeto al que buscar los comentarios
:type instance: :class:`db.Model`
:param query_id: identificador de la busqueda paginada
:type query_id: :class:`long`
:param page: pagina a buscar
:type page: :class:`integer`
:returns: [query_id, [:class:`geovote.models.Comment`]]
"""
if querier is not None and not querier.is_authenticated():
querier = None
if querier is not None and not isinstance(querier, User):
raise TypeError
if instance is None:
return None
from georemindme.paging import PagedQuery
from google.appengine.api import datastore
q = datastore.Query(kind='Comment',
filters={
'instance =': instance.key(),
'deleted =': False
})
q.Order(('created', datastore.Query.DESCENDING))
p = PagedQuery(q, id=query_id, page_size=7)
if async:
from google.appengine.datastore import datastore_query
q = Comment.all().filter('instance =',
instance).filter('deleted =',
False).order('-created')
return p.id, q.run(config=datastore_query.QueryOptions(limit=7))
comments = p.fetch_page(page)
from georemindme.funcs import prefetch_refpropsEntity
prefetch = prefetch_refpropsEntity(comments, 'user', 'instance')
return [
p.id,
[{
'id':
comment.key().id(),
'username':
prefetch[comment['user']].username,
'has_voted':
Vote.objects.user_has_voted(querier, comment.key())
if querier is not None else None,
'vote_counter':
comment['votes'],
'instance':
prefetch[comment['instance']],
'msg':
comment['msg'],
'created':
comment['created'],
} for comment in comments]
]
