def init():
rst_Ref = db.collection(u'root').document(u'restaurants')
#build restaurants document
items_Ref = db.collection(u'root').document(u'items')
rst_Ref.set({u'id': u'restaurants', u'numRestaurants': 0})
items_Ref.set({u'id': u'items', u'numItems': 0})
data = getData()
for idx, rst in enumerate(data):
rst_Ref.update({u'numRestaurants': fs.Increment(1)})
new_rst_ref = rst_Ref.collection('rstList').document(rst['name'])
# print(rst['loc'])
new_rst_ref.set({
'id': idx + 2, #set id in ascending from 0-n
'name': rst['name'],
'location': rst['loc'],
})
for item in rst['menu']:
menu_ref = new_rst_ref.collection('menu').document(item['name'])
menu_ref.set({u'name': item['name'], u'price': item['price']})
items_Ref.update({u'numItems': fs.Increment(1)})
new_item_Ref = items_Ref.collection('itemList').document(
item['name'])
new_item_Ref.set({u'name': item['name'], u'price': item['price']})
def add_tag(self, word: str, tag: str):
""" タグ追加
"""
tag_data = tag_service.get_tag(tag)
if tag_data:
docs = db.collection(self.collection_name).where(
"word", "==", word).limit(1).get()
if docs:
set_data = {
"tags": firestore.ArrayUnion([tag_data["text"]]),
"tags_cnt": {
tag_data["text"]: firestore.Increment(1)
},
"updated_at": datetime.now(),
"cnt": firestore.Increment(1),
}
# 初めてのタグはlikeに計算
if tag_data["text"] not in docs[0].to_dict()["tags"]:
set_data["like"] = firestore.Increment(tag_data["pnt"])
docs[0]._reference.set(set_data, merge=True)
return True
return False
def add_janken_result(self, result, session_id):
if result == 0:
set_result = "win_cnt"
elif result == 1:
set_result = "lose_cnt"
elif result == 2:
set_result = "draw_cnt"
else:
return False
doc_ref = db.collection(self.collection_session).document(
document_id=session_id)
doc_ref.set({
set_result: firestore.Increment(1)
}, merge=True)
doc_ref = db.collection(
self.collection_name).document("TOTAL")
doc_ref.set({
set_result: firestore.Increment(1)
}, merge=True)
doc_ref = db.collection(
self.collection_name).document(datetime.today().strftime("%y-%m-%d"))
doc_ref.set({
set_result: firestore.Increment(1)
}, merge=True)
return True
def test_analytics_male_female_count_increment(self):
fs = MockFirestore()
fs._data = {
'advertisements': {
'analytics': {
'male': {
'count': 20
},
'female': {
'count': 10
},
}
}
}
fs.collection('advertisements').document('analytics').update({
'male': {
'count': firestore.Increment(1)
},
'female': {
'count': firestore.Increment(1)
},
})
doc = fs.collection('advertisements').document(
'analytics').get().to_dict()
self.assertEqual(doc, {'male': {'count': 21}, 'female': {'count': 11}})
def test_document_update_transformerIncrementNested(self):
fs = MockFirestore()
fs._data = {
'foo': {
'first': {
'nested': {
'count': 1
},
'other': {
'likes': 0
},
}
}
}
fs.collection('foo').document('first').update({
'nested': {
'count': firestore.Increment(-1)
},
'other': {
'likes': firestore.Increment(1),
'smoked': 'salmon'
},
})
doc = fs.collection('foo').document('first').get().to_dict()
self.assertEqual(doc, {
'nested': {
'count': 0
},
'other': {
'likes': 1,
'smoked': 'salmon'
}
})
def update_highlights(self, wordlist, filename):
# Increments the firestore total upload count for that particular document
stats_collection = self.db.collection(u'pdfs').document(
filename).collection(u'words')
stats_collection.document(u'total').update(
{u'total': firestore.Increment(1)})
# Iterates through the collection to upload the highlight count of each individual word on the firebase
for wordstore in wordlist:
name = str(wordstore.getPage()) + "_" + str(
(wordstore.getX1() + wordstore.getX2()) / 2) + "_" + str(
wordstore.getY2())
current = stats_collection.document(name)
if current.get().exists:
current.update(
{'count': firestore.Increment(wordstore.getCount())})
else:
current.set(wordstore.to_dict())
# Initialises the list before pulling the updated firebase collection.
text_list = list()
docs = stats_collection.stream()
count = 1
for doc in docs:
current_doc = doc.to_dict()
if len(current_doc) > 1:
text_list.append(Token.from_dict(current_doc))
# text_list[-1].setCount(current_doc[u'count'])
else:
count = current_doc[u'total']
return text_list, count
def delete(self, identifier):
document = self._find(identifier)
doc_data = document.get().to_dict()
if doc_data['verified']:
self.metadata.update({
'total_verified': firestore.Increment(-1),
'total_documents': firestore.Increment(-1)
})
document.delete()
def add_system_cnt(self, key):
doc_ref = db.collection(self.collection_name).document("TOTAL")
doc_ref.set({
key: firestore.Increment(1),
}, merge=True)
doc_ref = db.collection(
self.collection_name).document(datetime.today().strftime("%y-%m-%d"))
doc_ref.set({
key: firestore.Increment(1),
}, merge=True)
def update_relationship():
"""
update_relationship() : increment/decrement relationship score between users.
- Input JSON should include:
- string for direction "discrete" (src->trgt) or "mutual" for both
- string for relationship type
- array of UUID strings. First UUID in the array is always the src, second is always trgt (for POC)
- int for how much to change the score (delta)
Note: This is currently implemented somewhat oddly during PoC while we decide
if we want to be able to update more than two relationships at once.
TODO (joeholley): Decrementing below init_score should be floored at
init_score (or deleted)
"""
try:
ur_logger = log.withFields({
'direction': request.json['direction'],
'relationship': request.json['relationship'],
'uuid_src': request.json['uuids'][0],
'uuid_trgt': request.json['uuids'][1],
'delta': request.json['delta'],
})
ur_logger.debug("updateRelationship called")
# TODO(joeholley): configurable initial score
if request.json['direction'] == 'mutual':
ur_logger.debug("bi-directional relationship update")
batch = db.batch()
# This is using a loop as it /could/ be easily made to modify more
# than two players simultaneously. Not settled on having this
# feature yet but could see it as useful in many group-based games.
for uuid_src in request.json['uuids']:
for uuid_trgt in request.json['uuids']:
if uuid_src != uuid_trgt:
# Nested JSON keys are handled using dot operators in firestore
key = "%s.%s" % (request.json['relationship'],
uuid_trgt)
batch.update(fs.document(uuid_src), {
key:
firestore.Increment(int(request.json['delta']))
})
batch.commit()
else:
ur_logger.debug("uni-directional relationship update")
key = "%s.%s" % (request.json['relationship'],
request.json['uuids'][1])
fs.document(request.json['uuids'][0]).update(
{key: firestore.Increment(int(request.json['delta']))})
return jsonify({"success": True}), 200
except Exception as e:
return f"An Error Occured: {e}"
def dec_unknown(self):
doc_ref = db.collection(
self.collection_name).document("TOTAL")
doc_ref.set({
"unknown_cnt": firestore.Increment(-1)
}, merge=True)
doc_ref = db.collection(
self.collection_name).document(datetime.today().strftime("%y-%m-%d"))
doc_ref.set({
"unknown_dec_cnt": firestore.Increment(1),
}, merge=True)
def add_unknown(self, word: str):
doc_ref = db.collection(
self.collection_name).document("TOTAL")
doc_ref.set({
"unknown_cnt": firestore.Increment(1)
}, merge=True)
doc_ref = db.collection(
self.collection_name).document(datetime.today().strftime("%y-%m-%d"))
doc_ref.set({
"unknown_add_cnt": firestore.Increment(1),
"unknown_add_list": firestore.ArrayUnion([word]),
}, merge=True)
def add_word_update(self, word: str):
doc_ref = db.collection(
self.collection_name).document("TOTAL")
doc_ref.set({
"word_update": firestore.Increment(1)
}, merge=True)
doc_ref = db.collection(
self.collection_name).document(datetime.date)
doc_ref.set({
"word_update": firestore.Increment(1),
"word_update_list": firestore.ArrayUnion([word]),
}, merge=True)
def dispense_done(self, amount):
# Cleanup and turnoff the LED
self.set_motor(MOTOR_OFF)
if amount > 0:
JobOnce(lambda: self.set_led('holder', LOW), seconds=3)
JobOnce(lambda: self.set_led('reader', HIGH), seconds=3)
# Notify server of departure
# Raise a flag that we are empty
self.game['is_empty'] = amount != self.dispense_no
# Check if we are empty, if so, we reduce credit
if self.game['is_empty']:
logger.info(f'We are empty, we only dispensed {amount} coins')
# Only reduce
self.area_ref.set(
{
'paid': firestore.Increment(amount),
'is_empty': self.game['is_empty'],
'players': {
self.current_uid: {
'present': False,
'credit': firestore.Increment(-amount),
}
}
},
merge=True)
else:
logger.info(f'Dispense done, gave {amount} coins')
self.area_ref.update({
'paid':
firestore.Increment(amount),
'is_empty':
self.game['is_empty'],
f'players.{self.current_uid}':
firestore.DELETE_FIELD,
})
del self.players[self.current_uid]
# Finally, remove player from area
self.player_ref.document(self.current_uid).set(
{
'area': None,
AREA: firestore.Increment(amount),
}, merge=True)
# Our flag that we are not dispensing
self.current_uid = None
self.dispense_no = 0
def add_bad(self, word: str):
""" bad加算
"""
docs = db.collection(self.collection_name).where("word", "==",
word).limit(1).get()
if docs:
docs[0]._reference.set(
{
"bad": firestore.Increment(1),
"updated_at": datetime.now(),
"cnt": firestore.Increment(1),
},
merge=True)
return True
return False
def _add(self,
data,
*,
validating_data=None,
validation_fields=None,
client,
metadata,
check_unique=False,
check_exists=False,
validation_client=None):
found_item = None
if validating_data is not None:
validate_against = deep_merge(data, validating_data)
else:
validate_against = data
if validation_fields is not None:
for field in validation_fields:
found_item = self._find({field: validate_against[field]},
validation_client)
if check_unique and found_item is not None:
return None
if check_exists and found_item is None:
return None
_, doc_ref = client.add(data)
metadata.update({'total_documents': firestore.Increment(1)})
return doc_ref.id
def test_document_update_transformerIncrementBasic(self):
fs = MockFirestore()
fs._data = {'foo': {'first': {'count': 1}}}
fs.collection('foo').document('first').update(
{'count': firestore.Increment(2)})
doc = fs.collection('foo').document('first').get().to_dict()
self.assertEqual(doc, {'count': 3})
def log_exit(doc, coll):
doc.update({
u'Count': firestore.Increment(-1)
})
coll.add({
u'Count': -1,
u'time': datetime.now()
})
def log_entrance(doc, coll):
doc.update({
u'Count': firestore.Increment(1)
})
coll.add({
u'Count': 1,
u'time': datetime.now()
})
def test_document_update_transformerIncrementNonExistent(self):
fs = MockFirestore()
fs._data = {'foo': {'first': {'spicy': 'tuna'}}}
fs.collection('foo').document('first').update(
{'count': firestore.Increment(1)})
doc = fs.collection('foo').document('first').get().to_dict()
self.assertEqual(doc, {'count': 1, 'spicy': 'tuna'})
def inc_table_header(self, **kwargs):
header_ref = self.get_table_header()
header_dict = header_ref.to_dict()
content = kwargs.copy()
for key, value in content.items():
content[key] = firestore.Increment(value)
header_dict[key] = header_dict.get(key, 0) + value
self.update_document(header_ref, content)
return header_dict
def _verify(self, id_str, *, client, metadata):
document = client.document(id_str)
if document.get().to_dict()['verified'] is True:
return False
document.update({'verified': True})
metadata.update({'total_verified': firestore.Increment(1)})
return True
def store_data(product):
global DB_CLIENT
if not DB_CLIENT:
DB_CLIENT = firestore.Client()
doc_ref = DB_CLIENT.collection(APP_COLLECTION).document(product)
doc_ref.set({
u"recomended_times": firestore.Increment(1),
}, merge=True)
def decrementItemQty(item_id: str, user_id: str):
db = firestore.Client()
cart_ref = db.collection(u'Users').document(user_id).collection(
u'Cart').document(item_id)
cart_ref.update({
u'quantity': firestore.Increment(-1),
u'timestamp': firestore.SERVER_TIMESTAMP
})
return document_to_dict(cart_ref.get())
def create_tr(transaction: Transaction, word_create: models.WordCreate,
tags: List[models.TagAct], taught: str, collect_word: str,
collect_unknown: str, collect_session: str):
""" 新規単語の追加で呼び出すトランザクション処理
"""
# unknownsコレクションにある場合は削除する
docs = db.collection(collect_unknown).where("word", "==",
word_create.word).stream()
for doc in docs:
transaction.delete(doc._reference)
system_service.dec_unknown()
set_like = 0
set_tags = []
set_tags_cnt = {}
for tag in tags:
set_tags.append(tag["text"])
set_tags_cnt[tag["text"]] = firestore.Increment(1)
set_like = set_like + tag["pnt"]
# wordsコレクションに追加
word_data = models.WordAll(**word_create.dict()).dict()
word_data["taught"] = taught
word_data["like"] = set_like
word_data["tags"] = set_tags
word_data["tags_cnt"] = set_tags_cnt
word_data["cnt"] = firestore.Increment(1)
word_data["index"] = system_service.get_system_data()["word_cnt"]
word_ref = db.collection(collect_word).document()
transaction.set(word_ref, word_data)
# sessionsコレクション更新
session_ref = db.collection(collect_session).document(document_id=taught)
session_data = {
"teach_words": firestore.ArrayUnion([word_create.word]),
"teach_refs": firestore.ArrayUnion([word_ref]),
"teach_cnt": firestore.Increment(1),
}
transaction.set(session_ref, session_data, merge=True)
return word_ref
def visit_count(event, context):
db = firestore.Client(project='airports-project')
if 'attributes' in event:
if 'page' in event['attributes']:
page_name = event['attributes']['page']
counter_ref = db.collection(u'visits').document(f'{page_name}')
if not counter_ref.get().exists:
counter_ref.set({u'counter': 1})
else:
counter_ref.update({u'counter': firestore.Increment(1)})
print(f'Incremented {page_name} counter visit')
else:
page_name = 'Unknown'
print('Nothing done')
def persist(client, pubname, collname, doc_id, document_dict):
# Check these values to determine if this is a Publication count incrementor message.
if collname is None or doc_id is None:
increment_publication(client, pubname, document_dict['count'])
else:
# Map the increment class to the count value.
document_dict['count'] = firestore.Increment(document_dict['count'])
# pubdoc is the firestore document for the given publication.
pubdoc = client.collection(u'publications').document(pubname)
# wrddoc is the document that stores the word and count
wrddoc = pubdoc.collection(collname).document(doc_id)
# Merge will allow the count to be incremented.
wrddoc.set(document_dict, merge=True)
log.debug('incremented word counter')
async def update_or_create(input: Counting, response: Response):
""" This Method Either creates the New Document for name or update the value if name already exists in docuemnts """
dict_data = {'name': input.name, 'value': input.value}
doc_ref = doc_collection.document(input.name)
record = doc_ref.get()
print(record.get(u'value'))
if record.exists:
doc_ref.update({u'value': firestore.Increment(input.value)})
else:
doc_ref.set(dict_data)
response.status_code = status.HTTP_201_CREATED
#to send the latest response
record = doc_ref.get()
return record.to_dict()
def _acid_update(transaction, doc_ref, event: Event):
snapshot = doc_ref.get(transaction=transaction)
if not snapshot.exists:
transaction.set(
doc_ref, {
u'{}'.format('count'): 1,
u'{}'.format('temperature'): event.temperature,
u'{}'.format('temperature_at'): event.timestamp,
u'{}'.format('updated_at'): firestore.SERVER_TIMESTAMP,
})
else:
transaction.update(
doc_ref, {
u'{}'.format('count'): firestore.Increment(1),
u'{}'.format('temperature'): event.temperature,
u'{}'.format('temperature_at'): event.timestamp,
u'{}'.format('updated_at'): firestore.SERVER_TIMESTAMP,
})
def job_game_tick(self):
tick = datetime.now(timezone.utc)
# logger.info('Main game tick')
updates = {}
for uid, player in self.players.items():
# Skip players that are not present
if player['present'] != True:
continue
# We limit the credits to [0, limit]
new_credit = max(
0,
min(player['credit'] + self.game['tick_amount'],
self.game['limit']))
# If there is no change, or if we have already more (and positive tick rate), continue
if player['credit'] == new_credit or (
self.game['tick_amount'] > 0
and player['credit'] > new_credit):
continue
# Check for update
if tick > player['tick'] + self.game['tick_seconds']:
logger.info(f'Give money to {uid}')
# Make sure we keep their checkin alignment
while tick > player['tick'] + self.game['tick_seconds']:
player['tick'] += self.game['tick_seconds']
# Update player
updates[uid] = {
'credit':
firestore.Increment(new_credit - player['credit']),
'tick': player['tick'],
}
# Update everything in one go
if len(updates) > 0:
self.area_ref.set({
'players': updates,
}, merge=True)
def _point(user_id, user_torate, event):
def switch_event(event):
return {'over': 'under', 'under': 'over'}[event]
edit_profile(
return_get=0,
user_id=user_torate,
dict_update={
'point_' + event: gcloud_firestore.Increment(1),
event + '_by': gcloud_firestore.ArrayUnion([user_id])
},
#dict_set={ 'spent_over': 0, 'spent_under': 0, 'point_'+event: 1,'point_'+switch_event(event): 0, event+'_by': gcloud_firestore.ArrayUnion([user_id]), 'day': today() }
dict_set={
'spent_over': 0,
'spent_under': 0,
'point_' + event: 1,
event + '_by': gcloud_firestore.ArrayUnion([user_id]),
'day': today()
} #remove 0
)