def update_spectator_feed(s, e, type, athlete=-1, score=-1):
session = Session.objects.get(pk=s)
if not session.admin_test_mode:
db = firestore.Client()
ath = Athlete.objects.filter(pk=athlete).first()
if ath != None:
ath_display = "(" + ath.team.abbreviation + ") " + ath.name
else:
ath_display = ""
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'competition_stream').add({
u'event':
e,
u'type':
type,
u'athlete':
athlete,
u'athlete_display':
ath_display,
u'score':
score,
u'timestamp':
datetime.utcnow(),
})
def routine_get(s, e):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'event_managers').document(str(e))
doc_dict = doc_ref.get().to_dict()
return doc_dict
def signup():
msg = ''
if request.method=='POST':
username = request.form['username']
email = request.form['email']
password = request.form['password']
cpassword = request.form['confirm-password']
mobile = request.form['mobile']
country = request.form['country']
flag=0
db = firestore.Client()
docsss = db.collection(u'users').stream()
for doc in docss:
temp=doc.to_dict()
if temp['username']==username:
msg = 'Account already exists!'
flag=1
break
else:
msg = 'You have successfully registered!'
data = {
u'username': username,
u'email': email,
u'password': password,
u'bussiness': "false",
u'mobile': mobile,
u'country':country
}
flag=0
if flag==0:
ussssse.add(data)
return render_template('login.html',msg=msg)
return render_template('signup.html',msg=msg)
def quiz_reminder(uid, module, quiz, quiz_ref=None):
time.sleep(10)
db = firestore.Client()
doc_ref = db.collection(u'users').document(uid)
curr = doc_ref.get().to_dict()
curr = curr[u'token']
if quiz_ref == None:
message = messaging.Message(
notification=messaging.Notification(
title='Remider to do task: {}'.format(quiz),
body='Here is a reminder to perform your task!',
),
token=curr,
)
else:
message = messaging.Message(
data={
'quiz': quiz_ref,
},
notification=messaging.Notification(
title='Remider to do quiz: {}'.format(quiz),
body='Time for you to refresh your memory with this quiz!',
),
token=curr,
)
# Send a message to the device corresponding to the provided
# registration token.
response = messaging.send(message)
def decorated_function(*args, **kwargs):
user = dict(session).get('profile', None)
# Você adicionaria uma verificação aqui e usaria o ID do usuário ou algo para buscar
# os outros dados desse usuário / verifique se existem
print(
"User: --------------------------------------------------------------"
)
print(user) # Por algum motivo user está None
print(type(user))
print(
"Profile: -----------------------------------------------------------"
)
profile = dict(session)['profile']['email']
print(type(profile))
if user:
db = firestore.Client()
if not db:
return 'Falha na conexão com banco de dados!'
users_ref = db.collection(u'users')
# Cadastra usuário que acessa pela primeira vez no Firestore
if not users_ref.where(u'user_gmail', u'==', profile['email']):
db.collection(u'users').add({
u'user_name': profile['name'],
u'user_gmail': profile['email'],
u'user_photo': profile['picture']
})
return f(*args, **kwargs)
return 'Você não está logado, nenhuma página para você!'
def initialize_firebase_client(self, credentials_path=None):
if credentials_path:
os.environ[
"GOOGLE_APPLICATION_CREDENTIALS"] = credentials_path
self.db = firestore.Client()
logger.info("Firebase client is initialized")
else:
logger.error(f"Credentials Path can not be empty {credentials_path}")
def routine_reset_previous(s, e):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'event_managers').document(str(e))
doc_ref.set({
u'previous_routine_status': 'F',
}, merge=True)
def get_all_topic():
db = firestore.Client()
docs = db.collection(u'Topic').stream()
topic = []
for doc in docs:
topic.append(doc.to_dict())
return topic
def set_stream_connected(s, camera_id, stream_connected):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'streams').document(str(camera_id))
doc_ref.set({
u'connected': stream_connected,
}, merge=True)
def set_stream_status(s, camera_id, stream_status):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'streams').document(str(camera_id))
doc_ref.set({
u'status': stream_status,
}, merge=True)
def routine_set_ejudge_ready(s, e, judge, ready):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'event_managers').document(str(e))
doc_ref.set({
judge: ready,
}, merge=True)
def routine_set_dscore(s, e, d, score):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'event_managers').document(str(e))
doc_ref.set({
d + 'score': score,
}, merge=True)
def stream_set_event(s, e, camera_id):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'streams').document(str(camera_id))
doc_ref.set({
u'event': e,
}, merge=True)
def __init_fsDB(self):
try:
auth_path = self.__credentials["googleAuthPath"]
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = auth_path
self.__fsDB = firestore.Client(
project=self.__settings["firestoreAddress"])
except:
self.__functional == False
def routine_set_stream(s, e, stream):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'event_managers').document(str(e))
doc_ref.set({
u'id': e,
u'stream': stream,
}, merge=True)
def update_credentials():
'''
Updates credentials and returns a firestore client
On cloud functions you don't need to call initialize app or use credentials
'''
# for cloud-function pushing
db = firestore.Client()
return db
def hello_world(request):
# Add a new document
db = firestore.Client()
politicos = db.collection('politicos').stream()
for p in politicos:
getDespesas(db,p.to_dict()['id'])
return 'end ok'
def set_start_value(s, e, team, sv, judge):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(str(s)).collection(
u'event_managers').document(str(e) + "_start_value")
doc_ref.set({
judge: sv,
u'team': team,
}, merge=True)
def update_e_ping(s, e, judge, deduct):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'event_managers').document(
str(e)).collection("e" + str(judge) + "deductions").add({
u'deduct':
deduct,
})
def cash_read():
db=firestore.Client()
try:
ret = db.collection(CASH_COLLECTION_NAME).document(CASH_DOCUMENT_NAME).get().to_dict()
except:
pass
if(not ret):
ret = {"time":FIRST_TIME}
return ret
def set_credit(s, e, team, credit):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'event_managers').document(str(e) + "_falls")
doc_ref.set({
u'team': team,
u'credit': credit,
}, merge=True)
def get_all_topic_message(theme):
db = firestore.Client()
refMessages = []
existing_posts = db.collection(u'Topic')
query = existing_posts.where(u'theme', u'==', theme)
results = query.stream()
for post in results:
message = post.to_dict()
refMessages.append(message['message'])
return refMessages
def index(request):
if not firebase_admin._apps:
firebase = firebase_admin.initialize_app()
db = firestore.Client()
collection = db.collection('Collection Python')
response = collection.stream()
response_dict = {data.id: data.to_dict() for data in response}
data = [{'response': response_dict}]
print(data)
return render(request, 'app/index.html')
def set_floor_timer(s, e, team, started):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'event_managers').document(str(e) + "_timer")
doc_ref.set({
u'started': started,
u'team': team,
u'start': datetime.utcnow(),
})
def cash_read():
db = firestore.Client()
try:
ret = db.collection(COLLECTION_NAME).document(
DOCUMENT_NAME).get().to_dict()
except:
pass
if (not ret):
ret = {"since_id": FIRST_TWEET_ID}
return ret
def add_message(emetteur, time, contenu, topic):
db = firestore.Client()
mon_message = dict()
mon_message = {
'emetteur': emetteur,
'time': time,
'contenu': contenu,
'topic': topic
}
doc_ref = db.collection('Message').add(mon_message)
def get_collection(laCollection):
db = firestore.Client()
listeNom = []
listeMdp = []
users_ref = db.collection(laCollection)
docs = users_ref.stream()
for doc in docs:
#print(f'{doc.id} => {doc.to_dict()}')
print(f'{doc.id} => {doc.to_dict.first}')
def get_collection(laCollection):
db = firestore.Client()
listeSavoir = []
docs = db.collection(laCollection).stream()
for doc in docs:
savoir = doc.to_dict()
listeSavoir.append(savoir['info'])
return listeSavoir
def db_init():
os.environ[
"GOOGLE_APPLICATION_CREDENTIALS"] = "treehacks-server/treehacks-304803-a327688e67f9.json"
# Use a service account
cred = credentials.Certificate(
'treehacks-server/treehacks-304803-a327688e67f9.json')
firebase_admin.initialize_app(cred)
db = firestore.Client()
return db
def set_fall(s, e, team, fall):
db = firestore.Client()
doc_ref = db.collection(u'sessions').document(
str(s)).collection(u'event_managers').document(str(e) + "_falls")
doc_ref.set({
u'fall': fall,
u'team': team,
u'start': datetime.utcnow(),
u'credit': '',
})
