def counters(self):
if self._counters is None:
from models_acc import UserCounter
self._counters = UserCounter.get_by_key_name('counters_%s' %
self.id,
parent=self.key())
return self._counters
def _del_follows(self, key):
'''
Borra un key de la lista de following
:param key: key del usuario a borrar
:type key: :class:`db.Key()
:returns: True si se borro el usuario, False si no se encontro
'''
from models_acc import UserFollowingIndex
index = UserFollowingIndex.all().ancestor(self.key()).filter(
'following =', key).get()
if index is not None:
index.following.remove(key)
try:
from models_acc import UserCounter
counter_result = self.counters_async(
) # obtiene los contadores de self
follow_query = UserCounter.all().ancestor(
key) # obtiene los contadores del otro usuario
follow_result = follow_query.run()
counter_result = counter_result.next()
follow_result = follow_result.next()
counter_result.set_followings(
-1) # sumamos uno al contador de following
follow_result.set_followers(
-1
) # sumamos uno al contador de followers del otro usuario
except:
return False
index.put()
return True
return False
def _del_follows(self, key):
'''
Borra un key de la lista de following
:param key: key del usuario a borrar
:type key: :class:`db.Key()
:returns: True si se borro el usuario, False si no se encontro
'''
from models_acc import UserFollowingIndex
index = UserFollowingIndex.all().ancestor(self.key()).filter('following =', key).get()
if index is not None:
index.following.remove(key)
try:
from models_acc import UserCounter
counter_result = self.counters_async() # obtiene los contadores de self
follow_query = UserCounter.all().ancestor(key) # obtiene los contadores del otro usuario
follow_result = follow_query.run()
counter_result = counter_result.next()
follow_result = follow_result.next()
counter_result.set_followings(-1) # sumamos uno al contador de following
follow_result.set_followers(-1) # sumamos uno al contador de followers del otro usuario
except:
return False
index.put()
return True
return False
def _add_follows(self, followiterator, key):
'''
Guarda el usuario en el ultimo index posible, si se ha llegado al maximo
numero de usuarios por lista, se crea uno nuevo.
:param followiterator: Iterador con la consulta para obtener los index, ordenador por fecha de creacion
asi el primero de la lista, sera el ultimo index posible.
:type followiterator: :class:`_QueryIterator`
:param key: key del usuario a añadir
:type key: :class:`db.Key()
:returns: True si se añadio el usuario
'''
from models_acc import UserFollowingIndex
try:
last_follow = followiterator.next() # como estan ordenados por fecha de creacion, carga el primero que seria el ultimo indice.
except StopIteration:
last_follow = UserFollowingIndex(parent=self)
if len(last_follow.following) < TIMELINE_PAGE_SIZE*2: # un maximo de usuarios en este index para que las listas no sean lentas
last_follow.following.append(key)
else: # creamos un index nuevo
last_follow = UserFollowingIndex(parent=self, following=[key])
try:
from models_acc import UserCounter
counter_result = self.counters_async() # obtiene los contadores de self
follow_query = UserCounter.all().ancestor(key) # obtiene los contadores del otro usuario
follow_result = follow_query.run()
counter_result = counter_result.next()
follow_result = follow_result.next()
counter_result.set_followings(+1) # sumamos uno al contador de following
follow_result.set_followers(+1)# sumamos uno al contador de followers del otro usuario
except:
return False
last_follow.put()
return True
def _tx(user):
try:
from models_acc import UserFollowingIndex, UserSettings, UserProfile, UserCounter
settings = UserSettings(key_name='settings_%s' % user.id,
parent=user,
language=language)
profile = UserProfile(key_name='profile_%s' % user.id,
parent=user,
username=user.username,
email=user.email)
followings = UserFollowingIndex(parent=user)
counters = UserCounter(key_name='counters_%s' % user.id,
parent=user)
db.put_async([settings, profile, followings, counters])
return True
except:
return False
def _add_follows(self, followiterator, key):
'''
Guarda el usuario en el ultimo index posible, si se ha llegado al maximo
numero de usuarios por lista, se crea uno nuevo.
:param followiterator: Iterador con la consulta para obtener los index, ordenador por fecha de creacion
asi el primero de la lista, sera el ultimo index posible.
:type followiterator: :class:`_QueryIterator`
:param key: key del usuario a añadir
:type key: :class:`db.Key()
:returns: True si se añadio el usuario
'''
from models_acc import UserFollowingIndex
try:
last_follow = followiterator.next(
) # como estan ordenados por fecha de creacion, carga el primero que seria el ultimo indice.
except StopIteration:
last_follow = UserFollowingIndex(parent=self)
if len(
last_follow.following
) < TIMELINE_PAGE_SIZE * 2: # un maximo de usuarios en este index para que las listas no sean lentas
last_follow.following.append(key)
else: # creamos un index nuevo
last_follow = UserFollowingIndex(parent=self, following=[key])
try:
from models_acc import UserCounter
counter_result = self.counters_async(
) # obtiene los contadores de self
follow_query = UserCounter.all().ancestor(
key) # obtiene los contadores del otro usuario
follow_result = follow_query.run()
counter_result = counter_result.next()
follow_result = follow_result.next()
counter_result.set_followings(
+1) # sumamos uno al contador de following
follow_result.set_followers(
+1) # sumamos uno al contador de followers del otro usuario
except:
return False
last_follow.put()
return True
def counters_async(self):
from models_acc import UserCounter
q = UserCounter.all().ancestor(self.key())
return q.run()
def counters_async(self):
from models_acc import UserCounter
q = UserCounter.all().ancestor(self.key())
return q.run()
def counters(self):
if self._counters is None:
from models_acc import UserCounter
self._counters = UserCounter.get_by_key_name('counters_%s' % self.id, parent=self.key())
return self._counters
