def PutPlayers(self, player_list, no_pairs):
''' Create a new PlayerPair Entity corresponding to each player pair for
pair numbers 1 ... no_pairs saving any useful information from
player_list and put it into Datastore as a child of this Tournament.
Also, the no_players has changed, generates a unique
(for this tournament) id associated with each pair.
Args:
player_list: list of dicts with keys pair_no (req), name (opt),
and email (opt)
no_pairs: the total number of pairs in this tournament. Exactly this many
PlayerPairs are created.
'''
pair_dict = {}
if player_list:
for player in player_list :
pair_no = player['pair_no']
del player['pair_no']
if pair_dict.get(pair_no):
pair_dict[pair_no].append(player)
else:
pair_dict[pair_no]= [player]
player_list = PlayerPair.query(ancestor=self.key).fetch()
# If the number of players doesn't change, we just override some fields
# in existing pairs. Otherwise, we delete existing pairs and create new
# ones.
override_existing = len(player_list) == no_pairs
if not override_existing:
random_ids = self._RandomId(no_pairs)
ndb.delete_multi([p.key for p in player_list])
else:
player_list.sort(key = lambda pp : pp.pair_no)
# The create a PlayerPair and put it into Datastore for each possible
# number.
for i in range(1, no_pairs + 1):
pair_members = pair_dict.get(i)
str_pair_members = json.dumps(pair_members) if pair_members else ''
if override_existing:
player_pair = player_list[i-1]
player_pair.players = str_pair_members
else:
player_pair = PlayerPair(players=str_pair_members,
pair_no=i, id=random_ids[i-1],
parent=self.key)
player_pair.key = PlayerPair.CreateKey(self, i)
player_pair.put()
python类delete_multi()的实例源码
def delete_account( self, delete_posts = False, token = '' ):
token_to_save = 'accountdelete'
if not token:
# there is no token if the user has no email address: they are deleted immediately. They must be logged in.
user_to_delete = self.enki_user
else:
# a user has followed a accountdelete token link. The user account associated with the token will be deleted
tokenEntity = EnkiModelTokenVerify.get_by_token( token )
user_to_delete = EnkiModelUser.get_by_id( tokenEntity.user_id )
# delete all user related tokens except any verify token related to account deletion that's not yet been used
if tokenEntity.type == token_to_save:
token_to_save = 'accountandpostsdelete'
verify_tokens_to_delete = EnkiModelTokenVerify.fetch_keys_by_user_id_except_type( user_to_delete.key.id(), token_to_save )
if verify_tokens_to_delete:
ndb.delete_multi( verify_tokens_to_delete )
email_rollback_tokens_to_delete = EnkiModelTokenEmailRollback.fetch_keys_by_user_id( user_to_delete.key.id())
if email_rollback_tokens_to_delete:
ndb.delete_multi( email_rollback_tokens_to_delete )
# Delete the user account and log them out.
if not HandlerBase.account_is_active( user_to_delete.key.id()):
# delete user if the account is inactive
display_names = EnkiModelDisplayName.fetch_keys_by_user_id(user_to_delete.key.id())
if display_names:
ndb.delete_multi( display_names )
user_to_delete.key.delete()
else:
# anonymise the user
if user_to_delete.email:
user_to_delete.email = None
if user_to_delete.password:
user_to_delete.password = None
if user_to_delete.auth_ids_provider:
user_to_delete.auth_ids_provider = []
user_to_delete.put()
# keep all historical display_names. Add a new current display_name '[deleted]' (unless it's already been deleted)
display_name = EnkiModelDisplayName.get_by_user_id_current( user_to_delete.key.id())
if display_name:
if display_name.prefix != EnkiModelDisplayName.DELETED_PREFIX or display_name.suffix != EnkiModelDisplayName.DELETED_SUFFIX:
EnkiModelDisplayName.set_display_name( user_to_delete.key.id(), EnkiModelDisplayName.DELETED_PREFIX, EnkiModelDisplayName.DELETED_SUFFIX )
# delete user's sent and received messages
EnkiModelMessage.delete_user_messages( user_to_delete.key.id())
# delete user's posts if required
if delete_posts:
EnkiModelPost.delete_user_posts( user_to_delete.key.id())
# log the deleted user out
if self.enki_user == user_to_delete.key.id():
self.log_out()
EnkiModelTokenAuth.revoke_user_authentications( user_to_delete.key.id())
def get(self):
"""Return API available methods."""
# Remove old data
cs = Category.query()
ndb.delete_multi([x.key for x in cs])
bs = Book.query()
ndb.delete_multi([x.key for x in bs])
# Count variables
categories_count = 0
subcategories_count = 0
books_count = 0
# NOQA: lxml tree from web page response and search for category boxes.
tree = html.fromstring(urllib2.urlopen(self.source_url).read())
category_boxes = tree.xpath('//div[@class="callout-row"]')
for category_box in category_boxes:
# Get box title by filtering all H3 tags without attributes.
category_name = category_box.xpath('.//h3[not(@*)]/text()')[0]
# Create category entity and update counters.
category = Category(name=category_name, category=True, subcategory=False) # NOQA
category.put()
categories_count += 1
# Get subcategories by looking for all divs with the right class.
subcategories = category_box.xpath('.//div[not(@class="product-row cover-showcase")]') # NOQA
book_expression = './/a'
# If categories, iterate each and append book with subcategory
for subcategory_box in subcategories:
# Ger subcategory title by filtering the first H3 tag.
subcategory_name = subcategory_box.xpath('.//h3/text()')[0]
# Create category entity and update counters.
subcategory = Category(name=subcategory_name, category=False, subcategory=True) # NOQA
subcategory.put()
subcategories_count += 1
books = subcategory_box.xpath(book_expression)
for book in books:
self.append_book(book, category, subcategory)
books_count += 1
# Else, get books and append each with category only
if not subcategories:
books = category_box.xpath(book_expression)
for book in books:
self.append_book(book, category)
books_count += 1
return self.reponse({
'status': 'ok',
'books_added': books_count,
'categories_added': categories_count,
'subcategories_added': subcategories_count,
})
