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
