def setUp(self): self.testbed = testbed.Testbed() self.testbed.activate() self.testbed.init_app_identity_stub() self.testbed.init_memcache_stub() self.testbed.setup_env(app_id='your-app-id', overwrite=True) # Stub the FCM admin module try: self._app = firebase_admin.get_app('tbans') except ValueError: self._app = firebase_admin.initialize_app(name='tbans') messaging._get_messaging_service(self._app).send = self._stub_send
def setUp(self): mapper = ClassMapper([Dog, Cat, Person, JackRussell, Monkey, Monarch]) # self.db = FirestoreWrapper(mapper, creds_path) cred = credentials.Certificate(CREDS) app = firebase_admin.initialize_app(cred) uid = 'some-uid' additional_claims = { 'premiumAccount': True } custom_token = auth.create_custom_token(uid, additional_claims) firebase_admin.delete_app(app) self.db = FirestoreWrapper(mapper, None, project_id=CREDS["project_id"], custom_token=custom_token.decode("utf-8"), api_key=API_KEY, namespace=NAMESPACE )
def garmin_callback(request): # the firebase app may or may not be initialized; if not, we do it now # we need to edit this code to check if the correct app (i.e. the one in the config) is the one initialized # there may be more than one app (e.g. during migration to new app id)... if len(firebase_admin._apps) == 0: cred = credentials.ApplicationDefault() firebase_admin.initialize_app(cred, { 'projectId': config.PROJECT_ID, }) db = firestore.client() # log some stuff (remove this code later as will have some "secrets" in it) logging.info(firebase_admin._apps) logging.info(utils.get_flask_request(request)) # Extract the required fields from the request oauth_token_request = '' oauth_verifier = '' try: oauth_token_request = request.args['oauth_token'] oauth_verifier = request.args['oauth_verifier'] except: logging.info( 'Required parameters not return: oauth_token={}, oauth_verifier={}' .format(utils.obfuscate_secret(oauth_token_request), utils.obfuscate_secret(oauth_verifier))) return make_response( 'Required call back parameters (oauth_token and oauth_verifier) not sent -- user denied access', 401) # Garmin seems to return null in the verifier if not authorized if oauth_verifier == 'null': logging.info( 'Authorization denied for Garmin. oauth_token={}, oauth_verifier={}' .format(utils.obfuscate_secret(oauth_token_request), utils.obfuscate_secret(oauth_verifier))) return make_response('App not authorized in Garmin', 401) # Find the corresponding previously save oauth token secret from Firestore request_token_ref = db.collection( config.GARMIN_REQUEST_TOKENS_COLLECTION).document(oauth_token_request) request_token_doc = request_token_ref.get() if not request_token_doc.exists: return make_response( 'Garmin request token doesnt exist in the database; cant map user (oauth_token_request={})' .format(utils.obfuscate_secret(oauth_token_request)), 401) request_token = request_token_doc.to_dict() logging.info( 'Found user from Garmin request token: uid={} (oauth_token_request={})' .format(request_token['uid'], utils.obfuscate_secret(oauth_token_request))) oauth_token_secret_request = request_token['secret'] # Complete auth by sending back verifier, token & previously saved secret to exchange for access token client = oauthlib.oauth1.Client( client_key=config.GARMIN_KEY, client_secret=config.GARMIN_SECRET, signature_type='BODY', resource_owner_key=oauth_token_request, verifier=oauth_verifier, resource_owner_secret=oauth_token_secret_request) # sign it uri, headers, body = client.sign( config.GARMIN_ACCESS_TOKEN_URL, http_method='POST', headers={'Content-Type': 'application/x-www-form-urlencoded'}, body='') # submit request response = requests.post(uri + '?' + body) if response.status_code != 200: logging.error('Garmin access token request failure {}: {} ({})'.format( response.status_code, response.reason, utils.obfuscate_secret(oauth_token_request))) return make_response('Garmin access token request failure', 401) # extract the access token qs = parse.parse_qs(response.text) oauth_token_access = qs['oauth_token'][0] oauth_token_secret_access = qs['oauth_token_secret'][0] logging.info( 'Access token received: uid={}, access_token={}, access_token_secret={}' .format(request_token['uid'], utils.obfuscate_secret(oauth_token_access), utils.obfuscate_secret(oauth_token_secret_access))) # In a Firestore transaction, do the following: # 1. invalidate the request token # 2. invalidate any old access token(s) for the user # 3. set the new access token @firestore.transactional def update_in_transaction(transaction, request_token_ref, user_ref, oauth_token_access, oauth_token_secret_access): # get the user user_snapshot = user_ref.get(transaction=transaction) user_current_token = user_snapshot.get('access_token') # invalidate request token transaction.update(request_token_ref, {'used': True}) logging.info('Set request token {} as used for {}'.format( utils.obfuscate_secret(request_token_ref.id), user_ref.id)) # add new token new_access_token_ref = db.collection( config.GARMIN_ACCESS_TOKENS_COLLECTION).document( oauth_token_access) transaction.set( new_access_token_ref, { 'uid': user_ref.id, 'secret': oauth_token_secret_access, 'active': True, 'usages': 0, 'created_ts': dt.utcnow() }) logging.info('Added new access token {} for {}'.format( utils.obfuscate_secret(new_access_token_ref.id), user_ref.id)) # create reference to new token transaction.set(user_ref, {'access_token': oauth_token_access}, merge=True) logging.info('Set user token {} for {}'.format( utils.obfuscate_secret(new_access_token_ref.id), user_ref.id)) # invalidate old token if user_current_token: existing_token_ref = db.collection( config.GARMIN_ACCESS_TOKENS_COLLECTION).document( user_current_token) transaction.update(existing_token_ref, {'active': False}) logging.info('Invalidate old token {} for {}'.format( utils.obfuscate_secret(existing_token_ref.id), user_ref.id)) transaction = db.transaction() user_ref = db.collection(config.USERS_COLLECTION).document( request_token['uid']) update_in_transaction(transaction, request_token_ref, user_ref, oauth_token_access, oauth_token_secret_access) return redirect(config.HOME_PAGE)
import firebase_admin from firebase_admin import credentials from firebase_admin import db cred = credentials.Certificate('../secret_key/serviceAccountKey.json') firebase_admin.initialize_app( cred, {'databaseURL': 'https://canrayfirebasepython.firebaseio.com/'}) def login(username, password): result = '' # proccess for key, val in data.items(): if username == val['username']: if password == val['password']: result = 'Login berhasil.' print("-----Data kamu-----\n{}\n{}\n{}".format( "Name: " + val['name'], "Username: "******"Password: " + val['password'])) break else: result = 'Password salah!' break else: result = 'Username tidak tersedia!' return print(result) ref = db.reference('/users') data = ref.get()
from firebase_admin import credentials, initialize_app, storage # Init firebase with your credentials cred = credentials.Certificate("./e-menu-db-daf663b26d59.json") initialize_app(cred, {'storageBucket': 'e-menu-db.appspot.com'}) # Đầu vào: link local # Đầu ra: url public def url_image_firebase(fileName): # Put your local file path bucket = storage.bucket() blob = bucket.blob(fileName) blob.upload_from_filename(fileName) # Opt : if you want to make public access from the URL blob.make_public() print("- Your file url", blob.public_url) return blob.public_url
def __init__(self): import firebase_admin try: self._firebase_app = firebase_admin.get_app('tbans') except ValueError: self._firebase_app = firebase_admin.initialize_app(name='tbans')
from django.contrib.auth import get_user_model from django.http import JsonResponse from django.shortcuts import render from django.views.generic import View from rest_framework.views import APIView from rest_framework.response import Response import os from firebase_admin import credentials, firestore, initialize_app import pdb import pandas as pd import firebase_admin from firebase_admin import credentials cred = credentials.Certificate('home/datakey.json') default_app = initialize_app(cred) db = firestore.client() def data_table(self): todo_ref = db.collection('csvjson') all_todos = [doc.to_dict() for doc in todo_ref.stream()] data = pd.DataFrame(all_todos) return data def bardf1990(self): data = data_table(1) df1990 = data.loc[[0, 7, 52, 94, 111, 126, 183], "CounTries"] dff1990 = data.loc[[0, 7, 52, 94, 111, 126, 183], "1990"] return list(df1990), list(dff1990)
def init(): cred = credentials.Certificate( 'rateanything-5f6d3-firebase-adminsdk-tcm1b-c1bb239c1d.json') firebase_admin.initialize_app(cred) db = firestore.client()
import untangle import firebase_admin from firebase_admin import credentials from firebase_admin import db cred = credentials.Certificate('NFL-Picks-11f89026ddbd.json') firebase_admin.initialize_app( cred, {'databaseURL': 'https://nfl-picks-b5e4d.firebaseio.com'}) root = db.reference() class Team(): def __init__(self, city, name, wins, losses, ties): self.city = city self.name = name self.wins = wins self.losses = losses self.ties = ties #dictionary that keeps track of team names, wins, losses, and ties. This gets reset for each season teams = { "ARI": Team("Arizona", "Cardinals", 0, 0, 0), "ATL": Team("Atlanta", "Falcons", 0, 0, 0), "BAL": Team("Baltimore", "Ravens", 0, 0, 0), "BUF": Team("Buffalo", "Bills", 0, 0, 0), "CAR": Team("Carolina", "Panthers", 0, 0, 0), "CHI": Team("Chicago", "Bears", 0, 0, 0), "CIN": Team("Cincinnati", "Bengals", 0, 0, 0), "CLE": Team("Cleveland", "Browns", 0, 0, 0), "DAL": Team("Dallas", "Cowboys", 0, 0, 0),
"measurementId": 'G-E40V768N33', } headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36" } urls = "https://search.naver.com/search.naver?sm=tab_hty.top&where=news&query=%EC%8B%B1%EC%96%B4%EA%B2%8C%EC%9D%B8&oquery=%EB%AC%B4%EC%95%BC%ED%98%B8&tqi=haryuwprvmsssuAaC%2BossssstHK-133305" links = [] news_names = 'singagain' posts_len = 0 # firebase = pyrebase.initialize_app(config) cred = credentials.Certificate("todayissue.json") firebase = firebase_admin.initialize_app( cred, {'databaseURL': "https://todayissue-21e8e-default-rtdb.firebaseio.com"}) db = db.reference('/') err_log = "{}.log".format(news_names) # 에러로그 저장 이름 save_news = "{}.txt".format(news_names) def errlog(er, erstr): now = datetime.now() errlog = open(err_log, "a+") # dc txt에 갤 넘버 저장 errlog_content = (str(now) + " // " + str(er) + erstr) errlog.write(str(errlog_content.strip()) + "\n") # dc txt 갤 넘버 작성 errlog.close() # dc txt 닫기 print(str(er) + " : " + erstr)
from flask import Flask, request, jsonify import firebase_admin from firebase_admin import credentials from firebase_admin import db cred = credentials.Certificate('mykey.json') firebase_admin.initialize_app( cred, {'databaseURL': 'https://kwnoti-fefb3.firebaseio.com/'}) app = Flask(__name__) def getdb(utr): if utr == "일반-학사": ref1 = db.reference("제목/일반-학사") ref2 = db.reference("링크/일반-학사") title_list = ref1.get() link_list = ref2.get() elif utr == "학생-봉사": ref1 = db.reference("제목/학생-봉사") ref2 = db.reference("링크/학생-봉사") title_list = ref1.get() link_list = ref2.get() elif utr == "등록-장학": ref1 = db.reference("제목/등록-장학") ref2 = db.reference("링크/등록-장학") title_list = ref1.get() link_list = ref2.get() elif utr == "입학-시설": ref1 = db.reference("제목/입학-시설") ref2 = db.reference("링크/입학-시설") title_list = ref1.get()
import firebase_admin from firebase_admin import credentials from firebase_admin import db from _datetime import datetime import sys # default_app = firebase_admin.initialize_app() cred = credentials.Certificate('config/config.json') firebase_admin.initialize_app(cred, { 'databaseURL': 'https://covid-python-tdb2020.firebaseio.com/' }) ref = db.reference('Texas') # print(ref.get()) date = datetime.now().strftime("%Y%m%d") # print(date) def save_friendswood(stats_dict): friendswood_ref = db.reference('Friendswood') data = friendswood_ref.child(date).get() key = None if data: key = next(iter(data)) if key: new_stat = friendswood_ref.child(date+ "/" + key).update(stats_dict) else: new_stat = friendswood_ref.child(date).push(stats_dict) print("Saved Friendswood: ", new_stat.path if new_stat != None else key)
#!/usr/bin/env python # -*- coding: utf-8 -*- import firebase_admin from firebase_admin import credentials from firebase_admin import firestore # Use the application default credentials cred = credentials.ApplicationDefault() firebase_admin.initialize_app(cred, { 'projectId': 'fukudak-firebase-red', }) db = firestore.client() doc_ref = db.collection(u'users').document(u'alovelace') doc_ref.set({u'first': u'Ada', u'last': u'Lovelace', u'born': 1815}) doc_ref = db.collection(u'users').document(u'aturing') doc_ref.set({ u'first': u'Alan', u'middle': u'Mathison', u'last': u'Turing', u'born': 1912 }) users_ref = db.collection(u'users') docs = users_ref.get() for doc in docs: print(u'{} => {}'.format(doc.id, doc.to_dict()))
import json import requests import firebase_admin from firebase_admin import credentials from firebase_admin import firestore from google.cloud import tasks_v2 from google.oauth2 import service_account cred = credentials.Certificate("C:/Users/elgue/Downloads/phirst-e425b-f32568f62ac2.json") firebase_admin.initialize_app(cred, { 'projectId': 'phirst-e425b', }) db = firestore.client() credentials = service_account.Credentials. from_service_account_file('C:/Users/elgue/Downloads/phirst-e425b-f32568f62ac2.json') client = tasks_v2.CloudTasksClient(credentials=credentials)
import firebase_admin from firebase_admin import db from firebase_admin import credentials import json import flask from flask_cors import CORS, cross_origin app = flask.Flask(__name__) CORS(app) app.config['CORS_HEADERS'] = 'Content-Type' cred = credentials.Certificate('./radception-database-credentials.json') firebase_admin.initialize_app( cred, options={'databaseURL': 'https://radception-database.firebaseio.com'}) USERS = db.reference('users') DEVICES = db.reference('devices') @app.route("/") @cross_origin() def hello(): return "Hello World!" @app.route('/users', methods=['POST']) @cross_origin() def create_user(): req = flask.request.json user = USERS.child(req["username"]).set(req) return flask.jsonify({'id': user.key}), 201
class ContextTask(TaskBase): abstract = True def __call__(self, *args, **kwargs): with app.app_context(): return TaskBase.__call__(self, *args, **kwargs) celery.Task = ContextTask return celery gh = Github(os.getenv('GITHUB_ACCESS_TOKEN')) cred = credentials.Certificate(os.path.join(os.path.dirname(__file__), '.firebase-admin.json')) firebase_app = firebase_admin.initialize_app(cred, options={ "databaseURL": "https://sc17-gatech-optica.firebaseio.com" }) root = db.reference() whitelist_ref = root.child('whitelist') app = Flask(__name__) # csrf = CSRFProtect(app) SESSION_TYPE = 'redis' app.config.from_object(__name__) Session(app) app.config.update( CELERY_BROKER_URL='redis://localhost:6379', CELERY_RESULT_BACKEND='redis://localhost:6379' ) celery = make_celery(app)
import time, os, subprocess os.environ['DISPLAY'] = ":0" GPIO.setmode(GPIO.BCM) trig = 13 echo = 19 who = 5 GPIO.setup(trig, GPIO.OUT) GPIO.setup(echo, GPIO.IN) print('start') client_socket = BluetoothSocket(RFCOMM) client_socket.connect(("98:D3:91:FD:8A:5D", 1)) cred = credentials.Certificate( 'double-skyline-265803-firebase-adminsdk-kxxmc-5841099f57.json') firebase_admin.initialize_app( cred, {'databaseURL': 'https://double-skyline-265803.firebaseio.com/'}) print('bluetooth Connected!') displayison = False maxidle = 10 lastsign = 0 ref = db.reference('SmartHome/raspberrpi') try: while True: now = time.time() stop = 0 start = 0 GPIO.output(trig, False) time.sleep(0.5) GPIO.output(trig, True)
from google.oauth2 import service_account from google.auth.transport.requests import Request from pprint import pprint import firebasePython app = Flask(__name__) CORS(app) api = Api(app) http_token_auth = HTTPTokenAuth(scheme='Token') app.config.from_pyfile("../config/app.default_settings") app.config.from_envvar("POND_SERVICE_SETTINGS") firebase_cred = credentials.Certificate(app.config["FIREBASE_CREDENTIAL"]) firebase_app = initialize_app(firebase_cred, {'databaseURL': app.config["FIREBASE_DATABASE_URL"]}) ref = db.reference() transloadit_client = client.Transloadit(app.config['TRANSLOADIT_KEY'], app.config['TRANSLOADIT_SECRET']) IMAGE_URI = 'imageUri' VIDEO_URI = 'videoUri' MIME = 'mime' VIDEO_DURATION = 'duration' PROCESSING_MSG = "the pond is singing and the pond is warm and the pond is starting to give form" @http_token_auth.verify_token def verify_token(token): if app.config["ENABLE_AUTH"]: try:
"private_key": os.environ["fb_key"].replace(r'\n', '\n'), "client_email": os.environ["fb_email"], "client_id": os.environ["fb_client_id"], "auth_uri": "https://accounts.google.com/o/oauth2/auth", "token_uri": "https://oauth2.googleapis.com/token", "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs", "client_x509_cert_url": os.environ["fb_cert_url"] }) firebase_admin.initialize_app(fb_creds) db = firestore.client() def message_has_trigger(msg, keyword): return re.search('\\b' + keyword + '\\b', msg.content.lower()) def message_mentions_bot(msg): return client.user.mentioned_in(msg) async def channel_is_muted(server_id, channel_id): server_ref = db.collection(u'mutes').document(str(server_id)) channel_ref = server_ref.collection(u'channels').document(str(channel_id))
import firebase_admin from firebase_admin import credentials from firebase_admin import db from firebase_admin import * firebase_admin.initialize_app(credentials, {'databaseURL': 'url'}) ref = db.reference(path') ref2 = db.reference('') def addData(ad, soyad, kullaniciAdi, sifre, mail): ref.set({ kullaniciAdi: { 'ad': ad, 'soyad': soyad, 'kullaniciAdi': kullaniciAdi, 'sifre': sifre, 'mail': mail, }, }) def sendTime(timer): ref2.set(
import sys from PyQt5.QtGui import * from PyQt5.QtWidgets import * from datetime import datetime import re from firebase_admin import db import math import firebase_admin from firebase_admin import credentials from google.cloud import storage import pyrebase #인증 cred = credentials.Certificate('myKey.json') firebase_admin.initialize_app( cred, {'databaseURL': 'https://graduate-work-462b3.firebaseio.com/'}) config = { "apiKey": "AIzaSyA8dTQrxY9oxS6azG6j3sChjtmvHdnr7Co", "authDomain": "graduate-work-462b3.firebaseapp.com", "databaseURL": "https://graduate-work-462b3.firebaseio.com", "projectId": "graduate-work-462b3", "storageBucket": "graduate-work-462b3.appspot.com", "messagingSenderId": "48451857603", "appId": "1:48451857603:web:808bdaad60b699d6b8c676", "measurementId": "G-JCEHY71WY4" } firebase = pyrebase.initialize_app(config) storage = firebase.storage() path_on_cloud = "food_img/Olive/"
import os import firebase_admin import configparser from firebase_admin import credentials, firestore, storage localDir = 'icones' remoteDir = 'champions' config = configparser.RawConfigParser() config.read('local.properties') # Use a service account cred = credentials.Certificate(config.get('Certificate', 'location')) firebase_admin.initialize_app( cred, {'storageBucket': config.get('Certificate', 'name')}) db = firestore.client() bucket = storage.bucket() for filename in os.listdir(localDir): blob = bucket.blob(remoteDir + '/' + filename) outfile = localDir + '/' + filename with open(outfile, 'rb') as my_file: blob.upload_from_file(my_file, content_type='image/png')
from McDonald import McDonald app = Flask(__name__) # Channel Access Token line_bot_api = LineBotApi('Channel Access Token') # Channel Secret handler = WebhookHandler('Channel Secret') # private_key private_key = credentials.Certificate('/app/service-account.json') # 初始化firebase firebase_admin.initialize_app(private_key) db = firestore.client() # Global LINE_USER_ID = None account = None # McDonald------------------ class Mask(object): """docstring for Mask.""" def __init__(self, account, password): super(Mask, self).__init__() self.paramString = account + password # Just Username + Password self.account = account # Username
import firebase_admin from firebase_admin import credentials from firebase_admin import db cred = credentials.Certificate('serviceAccountKey.json') firebase_admin.initialize_app( cred, {'databaseURL': 'https://solarbabesdb.firebaseio.com/'}) plantName = "0001" ref = db.reference('heliopots/' + plantName) ref.update({"message": "here is a sample message"})
from flask import Flask, render_template, request, flash, redirect, url_for, session from wtforms import Form, StringField, TextAreaField, RadioField, SelectField, validators, PasswordField from Magazine import Magazine from Book import Book import firebase_admin from firebase_admin import credentials, db cred = credentials.Certificate( 'cred/library-system-a3843-firebase-adminsdk-av5pi-b432c9b613.json') default_app = firebase_admin.initialize_app( cred, {'databaseURL': 'https://library-system-a3843.firebaseio.com/'}) root = db.reference() app = Flask(__name__) @app.route('/') def default(): return render_template('home.html') @app.route('/home') def home(): return render_template('home.html') @app.route('/viewpublications') def viewpublications(): publications = root.child('publications').get() list = [] #create a list to store all the publication objects print(publications)
We will first go through the functions available on firebase Then we will apply these functions in a class that will make our firebase code, usable on our app """ #%% """ Initializing the SDK(software developement kit) """ import firebase_admin from firebase_admin import credentials from firebase_admin import db # fetch the service account key JSON file contents cred = credentials.Certificate('peopleCounter-adminSDK.json') # initialize the app with a service account, granting admin priveleges firebase_admin.initialize_app(cred) print("hello") ref = db.reference('/') #set() # using set method, we create database with this. The structure of the file will be the same as the said database ref.set({ 'boxes': { 'box001': { 'color': 'red', 'width': 1, 'height': 3, 'length': 2 },
def _get_client(): """Generate and return a FireStore client using the service account.""" cred = credentials.Certificate( rel_to_base('keys', 'tunez-245820-047b7b31e116.json')) firebase_admin.initialize_app(cred) return firestore.client()
import firebase_admin from firebase_admin import credentials from firebase_admin import firestore credential = credentials.ApplicationDefault() default_app = firebase_admin.initialize_app() db = firestore.client() def get_users(): return db.collection('users').get() def get_user(user_id): return db.collection('users').document(user_id).get() def create_new_user(user_data): user_ref = db.collection('users').document(user_data.username) user_ref.set({'password': user_data.password}) def get_things_to_do(user_id): return db.collection('users').document(user_id).collection( 'things_to_do').get() def create_new_task(user_id, description): task_ref = db.collection('users').document(user_id).collection(
import json import time import os import xml.etree.ElementTree as ET from collections import OrderedDict from pyfcm import FCMNotification fcm_token = os.environ['FCM_TOKEN'] unipass_token = os.environ['UNIPASS_TOKEN'] ems_token = os.environ['EMS_TOKEN'] push_service = FCMNotification(api_key=str(fcm_token)) cred = credentials.Certificate( os.path.expanduser("~") + "/private/serviceAccountKey.json") firebase_admin.initialize_app( cred, {'databaseURL': 'https://custom-f54bb.firebaseio.com'}) ref = db.reference('users') snapshot = ref.get() def parseUnipass(traceNum, traceYear, nowStatus): print(str(traceNum)) parsedData = OrderedDict() parsedData.clear() newStatus = nowStatus parseURL = 'https://unipass.customs.go.kr:38010/ext/rest/cargCsclPrgsInfoQry/retrieveCargCsclPrgsInfo?crkyCn=' + str( unipass_token) + '&hblNo=' + str(traceNum) + '&blYy=' + str(traceYear) req = '' while req == '': try:
from django.utils.safestring import mark_safe from django.conf import settings import json import firebase_admin import paho.mqtt.subscribe as subscribe from firebase_admin import db from firebase_admin import credentials _CREDENTIAL = credentials.Certificate(settings.FIREBASE_CONFIG) _OPTIONS = { 'databaseURL': 'https://gdfor-prod.firebaseio.com/', 'httpTimeout': 10 } firebase_admin.initialize_app(_CREDENTIAL, _OPTIONS) _LIST_MAC_ADDRESS = db.reference('catraca-obra').get(shallow=True).keys() def index(request): context = { 'list_mac_address': _LIST_MAC_ADDRESS } if request.POST: mac_address = request.POST.get('mac_address_select') return redirect('monitoramento', mac_address) return render(request, 'index.html', context) def room(request, mac_address):
def user_mgt_app(): app = firebase_admin.initialize_app(testutils.MockCredential(), name='userMgt', options={'projectId': 'mock-project-id'}) yield app firebase_admin.delete_app(app)
def __init__(self): cred = credentials.Certificate(PAHT_CRED) firebase_admin.initialize_app(cred, {'databaseURL': URL_DB}) self.refHome = db.reference(REF_HOME) self.refDoor = self.refHome.child(REF_DOOR)
from firebase_admin import credentials from firebase_admin import firestore import google.cloud.exceptions from tweepy.streaming import StreamListener from tweepy import OAuthHandler from tweepy import Stream import json from Sastrawi.Stemmer.StemmerFactory import StemmerFactory from collections import Counter akun = ['548904824', '255409050', '480224156', '63433517', '82552414', '61379637', '79994423', '47251716', '260043508'] # ['@IndosatCare','@Telkomsel','@myXLCare','@triindonesia','@myXL','@IM3Ooredoo','@AXISgsm','@ask_AXIS','@simPATI'] kata_kunci = ['lambat', 'lelet', 'lola', 'lemot', 'koneksi', 'gsm', '3g', '4g', 'hsdpa', 'edge', 'jaring', 'ganggu'] cred = credentials.Certificate('kunci2.json') firebase_admin.initialize_app(cred) db = firestore.client() tweet_ref = db.collection('Tweet') kata_ref = db.collection("kata_kunci") last_ref = db.collection("lasttweet") factory = StemmerFactory() stemmer = factory.create_stemmer() def tweetstruct(user, text, t): data = { 'username': user, 'text': text, 'time': t,
from flask import Flask, request, make_response, jsonify import json import firebase_admin from firebase_admin import credentials from firebase_admin import firestore from dateutil.parser import parse import os cred = credentials.Certificate('./<YOUR CREDENTIAL>.json') default_app = firebase_admin.initialize_app(cred) db = firestore.client() app = Flask(__name__) log = app.logger @app.route("/", methods=['POST']) def webhook(): req = request.get_json(silent=True, force=True) try: action = req.get('queryResult').get('action') except AttributeError: return 'json error' # Action Switcher if action == 'reservation.reservation-yes': res = create_reservation(req) if action == 'view-set': res = view_set(req) else: log.error('Unexpected action.')
#!/usr/bin/env python import sys import os import rasterio from rio_cloudmask.equations import cloudmask from subprocess import check_output import firebase_admin from firebase_admin import credentials from firebase_admin import db cred = credentials.Certificate("mabl-k8s-demo-fb-key.json") firebase_admin.initialize_app(cred, { 'databaseURL': 'https://load-testing-160018.firebaseio.com/' }) DATA_IN_PATH = '/tmp/raw_data_in/' DATA_OUT_PATH = '/tmp/raw_data_out/' DATA_SIZE = 0 def increment_value(current_value): return current_value + 1 if current_value else 1 def increment_datasize(current_value): global DATA_SIZE return current_value + DATA_SIZE if current_value else DATA_SIZE
twitter = Okt() import firebase_admin from firebase_admin import credentials from firebase_admin import db import json import time, datetime app = Flask(__name__) db_url = 'https://firstproject-afb38.firebaseio.com/' cred = credentials.Certificate( "firstproject-afb38-firebase-adminsdk-r6fpm-9c4723acd5.json") default_app = firebase_admin.initialize_app(cred, {'databaseURL': db_url}) #send_message-------------------------------------- from pyfcm import FCMNotification import schedule from apscheduler.schedulers.background import BackgroundScheduler from apscheduler.jobstores.base import JobLookupError push_service = FCMNotification( api_key= 'AAAAkyLbc_g:APA91bHbxHV_Xfl8-CaFCFNQy_dD_s9PO5aikbG89JZ8gpi0T8Oga8saiu0d1GaicZwhWF53akjBxfjhKH016aNDhGNUV2dc6ZNwau7kDJherVqaK_hEjb0hOgkSMSsvQTdKqkYC7iwc' ) def send_message(token, name):
# File: superheroes.py import firebase_admin from firebase_admin import db import flask app = flask.Flask(__name__) firebase_admin.initialize_app( options={'databaseURL': 'https://simba-282ca.firebaseio.com/'}) SUPERHEROES = db.reference('') @app.route('/heroes', methods=['POST']) def create_hero(): req = flask.request.json hero = SUPERHEROES.push(req) return flask.jsonify({'id': hero.key}), 201 @app.route('/heroes/<id>') def read_hero(id): return flask.jsonify(_ensure_hero(id)) @app.route('/heroes/<id>', methods=['PUT']) def update_hero(id): _ensure_hero(id) req = flask.request.json SUPERHEROES.child(id).update(req) return flask.jsonify({'success': True})
import os import firebase_admin from firebase_admin import storage from firebase_admin.firestore import firestore firebase_admin.initialize_app() class FirebaseWrapper: def __init__(self): discord_id = os.getenv('DISCORD_BOT_ID') bucket_name = os.getenv('FIREBASE_STORAGE_BUCKET') self.fireDb = firestore.Client().collection(u'discord').document( discord_id) self.fire_storage = storage.bucket(bucket_name) self.fireDb.set({}, merge=True) def user_collection(self, user_id): return self.fireDb.collection("users").document(user_id) def get_discord_config(self): response = self.fireDb.get().to_dict() return {} if response is None else response def set_discord_config(self, item): self.fireDb.set(item, merge=True) def get_user_end_time(self, author_id): items = self.fireDb.get().to_dict() if 'end-time' in items: end_time = items['end-time']
def __init__(self, mapper, creds_path, project_id=None, custom_token=None, api_key=None, validator=None, read_only=False, name=None, namespace=None ): self.mapper = mapper self.validator = validator self.read_only = read_only self.api_key = api_key self.namespace = namespace self.expires = None self.data_adapter = FirestoreDataAdapter() # Use a service account options = {"httpTimeout": 5} app = None if custom_token is not None: # from device client self.user = self.sign_in_with_custom_token(custom_token) self.update_expires() self.creds = CustomToken(self.user["idToken"], project_id) app_name = name if name else firebase_admin._DEFAULT_APP_NAME try: app = firebase_admin.get_app(name=app_name) except ValueError as e: # ugly hack to account for different behaviour of google libs try: app = firebase_admin.initialize_app(self.creds, name=app_name, options=options) except Exception as e: self.creds = self.creds.get_credential() app = firebase_admin.initialize_app(self.creds, name=app_name, options=options) elif creds_path is not None: # in dev with service creds try: self.creds = credentials.Certificate(creds_path) app = firebase_admin.initialize_app(self.creds, options=options) except ValueError as e: print("already initaialised") else: # in app engine environment already_initialised = firebase_admin._DEFAULT_APP_NAME in firebase_admin._apps if not already_initialised: app = firebase_admin.initialize_app(options=options) self.db = firestore.client(app=app) self.app = app