def setUp(self):
self.SECRET = 'FAKE_FIREBASE_SECRET'
self.DSN = 'https://firebase.localhost'
self.EMAIL = '*****@*****.**'
self.authentication = FirebaseAuthentication(self.SECRET, self.EMAIL,
None)
self.firebase = FirebaseApplication(self.DSN, self.authentication)
def passwordstore(server=env.host_string,
service='system',
user='******',
password=False,
verbose=False):
if nicenametohost(server):
server = hosttonicename(nicenametohost(server))
from firebase.firebase import FirebaseApplication, FirebaseAuthentication
authentication = FirebaseAuthentication(keychain['firebaseapikey'], True,
True)
fbase = FirebaseApplication(keychain['firebaseappurl'], authentication)
if password:
resourcepath = '/passwords/' + server + '/' + service
data = {user: password}
if verbose:
print "Posting " + str(data) + " to " + resourcepath
result = fbase.patch(resourcepath,
data,
params={'print': 'pretty'},
headers={'X_FANCY_HEADER': 'VERY FANCY'})
if verbose:
print result
return result
else:
resourcepath = '/passwords/' + server + '/' + service + '/' + user
password = fbase.get(resourcepath, None)
if verbose:
print resourcepath + ':'
print password
return password
def update(request):
pno = request.GET.get("id")
fire = FirebaseApplication("https://mydemo-820c3.firebaseio.com/", None)
d = fire.get("myproduct/", pno)
d1 = fire.get("myproduct/", None)
return render(request, "index.html", {"d1": d, "d": pno, "data": d1})
def __init__(self):
self.version = "1.0.0"
print("""
▄▄▄▄▀ ▄ █ ▄███▄ ▄▀ ██ █▀▄▀█ ███ ▄█ ██ █▄▄▄▄ █▄▄▄▄ ██ ▄█ ▄█
▀▀▀ █ █ █ █▀ ▀ ▄▀ █ █ █ █ █ █ █ ██ █ █ █ ▄▀ █ ▄▀ █ █ ██ ██
█ ██▀▀█ ██▄▄ █ ▀▄ █▄▄█ █ ▄ █ █ ▀ ▄ ██ █▄▄█ █▀▀▌ █▀▀▌ █▄▄█ ██ ██
█ █ █ █▄ ▄▀ █ █ █ █ █ █ █ ▄▀ ▐█ █ █ █ █ █ █ █ █ ▐█ ▐█
▀ █ ▀███▀ ███ █ █ ███ ▐ █ █ █ █ ▐ ▐
▀ █ ▀ █ ▀ ▀ █
▀ ▀ ▀
""")
self.p = None
self.continua = True
self.senha = ''
self.app = FirebaseApplication(
'https://thegambiarragame.firebaseio.com', authentication=None)
self.authentication = FirebaseAuthentication(
'4PjjnBreuNDHH1vEnFcmURL2nVSNHRHR1vl5voIk',
'*****@*****.**',
extra={'id': 123})
self.app.authentication = self.authentication
x = ''
for i in range(11):
x += '.'
if len(x) == 4:
x = ''
print("", end="\rCarregando" + x)
time.sleep(.3)
print("", end="\r")
def retrieveData():
firebase = FirebaseApplication("https://commuteapp-90b42.firebaseio.com")
retrieveData = firebase.get("/Shreyas", None)
print(dict(retrieveData))
retrieveData = jsonify(retrieveData)
print(type(retrieveData))
return retrieveData
def firebase_simple_get(request, entity):
"""
Simple Firebase Get
"""
firebase = FirebaseApplication(DSN, authentication)
firebase_people_data = firebase.get(entity, None)
return firebase_people_data
def mass(self, event):
from firebase.firebase import FirebaseApplication
firebase = FirebaseApplication('https://iotfinalproject-cea51.firebaseio.com/')
if self._measureCnt == 1:
print "Measuring weight..."
if (event.totalWeight > 2):
self._events[self._measureCnt] = event.totalWeight*2.20462
self._measureCnt += 1
if self._measureCnt == WEIGHT_SAMPLES:
self._sum = 0
for x in range(0, WEIGHT_SAMPLES-1):
self._sum += self._events[x]
self._weight = self._sum/WEIGHT_SAMPLES
self._measureCnt = 0
# Getting weight reading
weight = str(self._weight) + " lbs"
# Getting timestamp
timestamp = datetime.datetime.now().strftime("%d-%b-%Y")
print (timestamp)
print (weight)
# Post these results to firebase
post = firebase.post('/weight/', {'weight':weight, 'date':timestamp})
print (post)
print ("Now taking the photos!")
# Start the takePhotos() method in photos.py
photos.takePhotos()
sys.exit()
if not self._measured:
self._measured = True
def setUp(self):
self.SECRET = 'FAKE_FIREBASE_SECRET'
self.DSN = 'https://firebase.localhost'
self.EMAIL = '*****@*****.**'
self.UID = '123'
self.authentication = FirebaseAuthentication(
self.SECRET, self.EMAIL, auth_payload={'uid': self.UID})
self.firebase = FirebaseApplication(self.DSN, self.authentication)
def delete(request):
pno = request.POST.get("t1")
print(pno)
fire = FirebaseApplication("https://mydemo-820c3.firebaseio.com/", None)
fire.delete("myproduct", pno)
d = fire.get("myproduct/", None)
return render(request, "index.html", {"data": d})
def show(request):
pno = request.POST.get("t1")
pname = request.POST.get("t2")
pprice = request.POST.get("t3")
fire = FirebaseApplication("https://mydemo-820c3.firebaseio.com/", None)
d1 = fire.get("myproduct", pno, {"pname": pname, "pprice": pprice})
return render(request, "index.html", d1)
def __init__(self):
self.app = FirebaseApplication('https://vegans2godatabase.firebaseio.com', authentication=None)
self.authentication = FirebaseAuthentication('Wg6XvS7W0UftiQlBnCM1tt8gVSIE7exereBXcYx0', '*****@*****.**', extra={'id': 123})
self.app.authentication = self.authentication
self.cod_pedido = 0
self.dic_bebida = {}
self.dic_comida = {}
self.produto = Produto()
self.pedido = []
def saveProduct(request):
no = request.POST.get("t1")
name = request.POST.get("t2")
price = request.POST.get("t3")
fire = FirebaseApplication("https://djangoproduct.firebaseio.com/", None)
fire.put("product", no, {"name": name, "price": price})
d1 = fire.get("product", None)
return render(request, "index.html", {"data": d1})
def get(self, request, postalcode):
'''
Ugh
'''
from bs4 import BeautifulSoup
import re
firebase = FirebaseApplication(DSN, authentication)
firebase_locales_directory = firebase.get('/locales/directory', None)
location_found = False
for idx in enumerate(firebase_locales_directory):
if idx[1].find(postalcode) is not -1:
location_found = True
print 'Local location found.'
if location_found is False:
_postalcode = int(postalcode) + 1
if idx[1].find(str(_postalcode)) is not -1:
location_found = True
print 'Local location found.'
if location_found is False:
_postalcode = int(postalcode) - 1
if idx[1].find(str(_postalcode)) is not -1:
location_found = True
print 'Local location found.'
try:
if location_found is False:
print 'Pinging https://co-opcreditunions.org.'
r = requests.get(
'https://co-opcreditunions.org/locator/search-results/?loctype=S&zip='
+ postalcode +
'&cuname=&maxradius=20&country=&Submit=Search')
soup = BeautifulSoup(r.text, "html5lib")
scripts = [s.extract() for s in soup('script')]
locations = []
data = scripts[7].text
first_pass = data.split(']]')
second_pass = first_pass[0].split('[[')
third_pass = second_pass[1].split('],[')
if len(firebase_locales_directory) > 0:
locations = firebase_locales_directory
else:
locations = []
for idx in enumerate(third_pass):
location_datum = idx[1]
reversed_location_datum = location_datum[::-1]
final_full_location_datum = reversed_location_datum[::-1]
locations.append(final_full_location_datum)
firebase_people_data = firebase.put('/locales', 'directory',
locations)
else:
firebase_people_data = firebase_locales_directory
content = {'data': firebase_people_data}
return Response(content)
except ObjectDoesNotExist:
raise Http404
def index(request):
firebase_config = FirebaseConfig()
fire = FirebaseApplication(firebase_config.databaseURL)
wifis = fire.get('/text', None)
template = loader.get_template('PassManagerApp/index.html')
context = {
'wifis': wifis,
}
return HttpResponse(template.render(context, request))
def savedata(request):
pno=request.POST.get('t1')
pname = request.POST.get('t2')
pprice = request.POST.get('t3')
fire=FirebaseApplication('https://merchant-a8a0f.firebaseio.com/',None)
fire.put('product',pno,{'name':pname,'price':pprice})
d1=fire.get('product',None)
#print(d1)
return render(request,'index.html',{'data':d1})
def DBConnection(self):
self.firebaseClient = FirebaseApplication(
'https://eat2fit-adcd2.firebaseio.com', authentication=None)
authentication = FirebaseAuthentication(
'JQxgwXKOwoBa5piS5cphXoc0ToiJaq2qDwAkPzPo',
'*****@*****.**',
extra={'id': 'kRZ84YKZXPS9ZIIULOVOV8pXUQt2'})
self.firebaseClient.authentication = authentication
user = authentication.get_user()
def __init__(self):
self.app = FirebaseApplication('https://vegans2godatabase.firebaseio.com', authentication=None)
self.authentication = FirebaseAuthentication('Wg6XvS7W0UftiQlBnCM1tt8gVSIE7exereBXcYx0', '*****@*****.**', extra={'id': 123})
self.app.authentication = self.authentication
self.cod_produto = 0
self.nome = ""
self.status = ""
self.descricao = ""
self.valor = .0
self.dic_prod = {}
def remove():
firebase = FirebaseApplication(url, None)
name = str(input("Enter Name: "))
check = firebase.get('/Employee/{}' .format(name),"Password")
if check == None :
print(name ,"does not exist")
else :
firebase.delete("/Employee","{}".format(name))
print(name,"has been removed")
menu()
return
def save(request):
pno = request.POST.get("t1")
pname = request.POST.get("t2")
pprice = request.POST.get("t3")
fire = FirebaseApplication("https://mydemo-820c3.firebaseio.com/", None)
p = fire.put("myproduct", pno, {
"pname": pname,
"pprice": pprice,
})
d = fire.get("myproduct", None)
return render(request, "index.html", {"data": d})
class Pedido:
def __init__(self):
self.app = FirebaseApplication('https://vegans2godatabase.firebaseio.com', authentication=None)
self.authentication = FirebaseAuthentication('Wg6XvS7W0UftiQlBnCM1tt8gVSIE7exereBXcYx0', '*****@*****.**', extra={'id': 123})
self.app.authentication = self.authentication
self.cod_pedido = 0
self.dic_bebida = {}
self.dic_comida = {}
self.produto = Produto()
self.pedido = []
def criar_pedido(self, user):
self.produto.listar_produtos_disponiveis()
p = str(input("\n •Digite o codigo dos produtos desejados separando por espaços: "))
plis = p.split()
# print(plis)
for x in plis:
self.pedido.append('00' + x)
user = user.replace(" ", "")
for x in self.pedido:
qt = self.app.get("/Pedidos/" + user, x)
if qt is None:
qt = 1
elif qt >= 1:
qt += 1
self.app.put("/Pedidos/" + user, x, qt)
print("Pedido Realizado Com sucesso")
self.imprimir_pedido(user)
def buscar_pedido(self):
pass
def editar_pedido(self):
pass
def imprimir_pedido(self, user):
litas = []
p = """
Pedido de {0}
=======================
"""
for ftstr in self.pedido:
qt = str(self.app.get("/Pedidos/" + user, ftstr))
nome = str(self.app.get('/Produtos/' + ftstr, 'Nome'))
if ftstr in litas:
continue
else:
p += '\n' + nome + ' ------ ' + qt + 'x'
litas.append(ftstr)
p += '\n' + "======================="
print_pedido(p.format(user), user)
def removetable():
firebase = FirebaseApplication(url, None)
tableno = str(input("Enter Table No: "))
check = firebase.get('/Table/{}' .format(tableno),"Status")
if check == None :
print("Table does not exist")
else :
firebase.delete("/Table","{}".format(tableno))
print("Table",tableno,"deleted")
menu()
return
def add():
firebase = FirebaseApplication(url, None)
name = str(input("New Employee's name: "))
check = firebase.get('/Employee/{}' .format(name),"Password")
if check == None :
pw = str(input("Enter Password: "******"/Employee", name, {"Password": pw, "CardNo":"Nil"})
print(name ,"has been added")
else :
print(name ,"already exist")
menu()
return
def change():
firebase = FirebaseApplication(url, None)
pw = str(input("Current password: "******"New password: "******"/Employee/{}".format(name),{"Password":pw})
print("Update sucessful")
menu()
else:
print("Invalid Password")
change()
return
def __store_firebase(self):
"""
"""
authentication = FirebaseAuthentication(self.__config.get('firebase', 'firebase.database_secret'), None)
#user = authentication.get_user()
#print authentication.extra
#print user.firebase_auth_token
firebase = FirebaseApplication(self.__config.get('firebase', 'firebase.url'), authentication)
result = firebase.post(self.__config.get('firebase', 'firebase.path'), self.__data)
log_success('[+] Stored on firebase: {0}'.format(result['name']))
def handle(self, *args, **options):
custeom_event_qs = (
CustomEvent.objects
.select_related('begin_time', 'end_time')
)
keynote_event_qs = (
KeynoteEvent.objects
.select_related('begin_time', 'end_time')
)
proposed_talk_event_qs = (
ProposedTalkEvent.objects
.select_related('begin_time', 'end_time', 'proposal__submitter')
)
sponsored_event_qs = (
SponsoredEvent.objects
.select_related('begin_time', 'end_time', 'host')
)
self.stdout.write('Dumping schedule...', ending=' ')
schedule_data = dumpers.dump_schedule(itertools.chain(
custeom_event_qs,
keynote_event_qs,
proposed_talk_event_qs,
sponsored_event_qs,
))
self.stdout.write('Done')
self.stdout.write('Dumping event details...', ending=' ')
event_data = {
str(event.proposal.pk): dumpers.dump_proposal(event.proposal)
for event in proposed_talk_event_qs
}
event_data.update({
'sponsored_{}'.format(e.pk): dumpers.dump_sponsored_event_detail(e)
for e in sponsored_event_qs
})
self.stdout.write('Done')
app = FirebaseApplication(settings.FIREBASE_URL)
self.stdout.write('Uploading schedule...', ending=' ')
for key, value in schedule_data.items():
self.stdout.write(key, ending=' ')
data = {'date': key, 'slots': value}
app.put('{}/schedule'.format(settings.FIREBASE_DB), key, data)
self.stdout.write('Done')
self.stdout.write('Uploading events...', ending=' ')
app.put(settings.FIREBASE_DB, 'events', event_data)
self.stdout.write('Done')
def addtable():
firebase = FirebaseApplication(url, None)
b = 0
tableno = str(input("Enter Table No: "))
check = firebase.get('/Table/{}' .format(tableno),"Status")
if check == None :
add = firebase.put("/Table", tableno, {"Status": "Vacant" ,"Name": "Nil"})
print("Table",tableno,"created")
else :
print("Table already exist")
menu()
return
def diagnose():
app = FirebaseApplication('https://smartmachine-ed87d.firebaseio.com/')
list_data = []
while True:
heart_data = app.get('/heart_rate', None)
if heart_data['10'] != 0:
for i in range(10, 0, -1):
heart_data['%d' % i] = 60 / heart_data['%d' % i]
list_data.append(heart_data['%d' % i] * 1000)
heart_data = dict.fromkeys(heart_data, 0)
print(list_data)
app.put('/', 'heart_rate', heart_data)
if (len(list_data) % 30 == 0):
stress = RR_to_features(list_data)
list_data.clear()
def turmas():
with open('config.json') as data_file:
config = json.load(data_file)
print config
req = urllib2.Request(config['url'] + '/turma')
req.add_header('Authorization', 'Basic ' + config['key'])
resp = urllib2.urlopen(req)
content = resp.read()
turmas = json.loads(content)
print content
fb = FirebaseApplication(config['urlDatabase'], None)
for turma in turmas:
response = fb.post('turmas/', turma, connection=None)
def catequizandos():
with open('config.json') as data_file:
config = json.load(data_file)
print config
req = urllib2.Request(config['url'] + '/catequizando/page/0/300')
req.add_header('Authorization', 'Basic ' + config['key'])
resp = urllib2.urlopen(req)
content = resp.read()
ctq = json.loads(content)
print content
fb = FirebaseApplication(config['urlDatabase'], None)
for c in ctq['content']:
response = fb.post('catequizandos/', c, connection=None)
def catequizandos():
with open('config.json') as data_file:
config = json.load(data_file)
print config
req = urllib2.Request(config['url'] + '/catequizando/page/0/300')
req.add_header('Authorization', 'Basic ' + config['key'] )
resp = urllib2.urlopen(req)
content = resp.read()
ctq = json.loads(content)
print content
fb = FirebaseApplication(config['urlDatabase'], None)
for c in ctq['content']:
response = fb.post('catequizandos/', c, connection=None)
def turmas():
with open('config.json') as data_file:
config = json.load(data_file)
print config
req = urllib2.Request(config['url'] + '/turma')
req.add_header('Authorization', 'Basic ' + config['key'])
resp = urllib2.urlopen(req)
content = resp.read()
turmas = json.loads(content)
print content
fb = FirebaseApplication(config['urlDatabase'], None)
for turma in turmas:
response = fb.post('turmas/', turma, connection=None)
def ContactDetails(request):
f_name = request.POST.get("c1")
l_name = request.POST.get("c2")
email = request.POST.get("c3")
comment = request.POST.get("c4")
fire = FirebaseApplication("https://djangoweb1-ec1db.firebaseio.com/",
None)
fire.put(
"contact", "ContactDetails", {
"firstname": f_name,
"lastname": l_name,
"email": email,
"comment": comment
})
return render(request, "INDEX.html", {
"type": "contact",
"message": "Successfully Your FeedBack Given"
})
def main(argv):
cont = 0
fb = FirebaseApplication('https://py-firebase.firebaseio.com/', None)
new_user = '******'
response = fb.post('/users', new_user, connection=None, params={'print': 'pretty'}, headers={'X_FANCY_HEADER': 'VERY FANCY'})
cont = cont + 1
print cont
print response
responseGet = fb.get('/users', None)
print 'response - get'
print responseGet
def catequizando_turma():
with open('config.json') as data_file:
config = json.load(data_file)
print config
req = urllib2.Request(config['url'] + '/turma')
req.add_header('Authorization', 'Basic ' + config['key'])
resp = urllib2.urlopen(req)
content = resp.read()
lista = json.loads(content)
fb = FirebaseApplication(config['urlDatabase'], None)
c = fb.get('catequizandos', '-KLiNSOqJcAC62KDbwwk', connection=None)
print c
for t in lista:
print t
t['KLiNSOqJcAC62KDbwwk'] = c
response = fb.post('turmas/', t, connection=None)
def clean_data(self):
uncleaned = self.dump_firebase.get_all()
uncleaned = uncleaned or {}
firebase_clean = FirebaseApplication(app.config["FIREBASE_CLEAN"], None)
cleaned = firebase_clean.get("/", None)
for airport_code, date_status_dict in uncleaned.items():
if type(date_status_dict) != dict:
print airport_code, date_status_dict
continue
for date, event in date_status_dict.items():
if airport_code in cleaned and date in cleaned[airport_code]:
continue
filtered_data = utils.get_clean_data(event)
try:
firebase_clean.put(url="/"+airport_code, name=date, data=filtered_data)
print "Cleaned", airport_code, date
except Exception as e:
print "Could not clean", airport_code, date, event
print e
def main(argv):
cont = 0
fb = FirebaseApplication("https://py-firebase.firebaseio.com/", None)
new_user = "******"
response = fb.post(
"/users", new_user, connection=None, params={"print": "pretty"}, headers={"X_FANCY_HEADER": "VERY FANCY"}
)
cont = cont + 1
print cont
print response
responseGet = fb.get("/users", None)
print "response - get"
print responseGet
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.setup_env(
app_id='your-app-id',
my_config_setting='example',
overwrite=True)
self.SECRET = 'FAKE_FIREBASE_SECRET'
self.DSN = 'https://firebase.localhost'
self.EMAIL = '*****@*****.**'
self.authentication = FirebaseAuthentication(self.SECRET, self.EMAIL,
None)
self.firebase = FirebaseApplication(self.DSN, self.authentication)
def get_flight_info_from_firebase(self):
response = self.source_firebase.get("", None)
updated = parser.parse(response["_updated"])
if updated <= self.last_updated + self.delta:
raise Exception("Not time to sync yet.")
print "Syncing Airpot Delays from", updated.isoformat()
self.last_updated = updated
update_str = updated.isoformat()
firebase_clean = FirebaseApplication(app.config["FIREBASE_CLEAN"], None)
for airport_code, info in response.items():
# this is not an airport :)
if airport_code == "_updated": continue
try:
self.dump_firebase.firebase.put(url="/"+airport_code, name=update_str, data=info)
filtered_data = utils.get_clean_data(info)
firebase_clean.put(url="/"+airport_code, name=update_str, data=filtered_data)
except Exception as e:
print "Something failed", e
self.dump_firebase.firebase.put("/", "last_updated", update_str)
def passwordstore(server=env.host_string, service='system', user='******', password=False, verbose=False):
if nicenametohost(server):
server = hosttonicename(nicenametohost(server))
from firebase.firebase import FirebaseApplication, FirebaseAuthentication
authentication = FirebaseAuthentication(keychain['firebaseapikey'], True, True)
fbase = FirebaseApplication(keychain['firebaseappurl'], authentication)
if password:
resourcepath = '/passwords/' + server + '/' + service
data = {
user: password
}
if verbose:
print "Posting " + str(data) + " to " + resourcepath
result = fbase.patch(resourcepath, data, params={'print': 'pretty'}, headers={'X_FANCY_HEADER': 'VERY FANCY'})
if verbose:
print result
return result
else:
resourcepath = '/passwords/' + server + '/' + service + '/' + user
password = fbase.get(resourcepath, None)
if verbose:
print resourcepath + ':'
print password
return password
class FirebaseTestCase(unittest.TestCase):
def setUp(self):
self.SECRET = 'FAKE_FIREBASE_SECRET'
self.DSN = 'https://firebase.localhost'
self.EMAIL = '*****@*****.**'
self.authentication = FirebaseAuthentication(self.SECRET, self.EMAIL,
None)
self.firebase = FirebaseApplication(self.DSN, self.authentication)
def test_build_endpoint_url(self):
url1 = os.path.join(self.DSN, 'users', '1.json')
self.assertEqual(self.firebase._build_endpoint_url('/users', '1'), url1)
url2 = os.path.join(self.DSN, 'users/1.json')
self.assertEqual(self.firebase._build_endpoint_url('/users/1', None), url2)
def test_make_get_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.get('url', 'shapshot', params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
def test_make_post_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.post('url', {}, params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
def test_make_put_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.put('url', 'snapshot', {}, params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
def test_make_patch_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.patch('url', {}, params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
def test_make_delete_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.delete('url', 'snapshot', params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
#!/usr/bin/python
# Importamos la libreira de PySerial
import serial
import datetime
from firebase.firebase import FirebaseApplication, FirebaseAuthentication
# Abrimos el puerto del arduino a 9600
PuertoSerie = serial.Serial('COM14', 9600)
SECRET = '0N3Ti2UVYXMvsNMyJSbHvAVxTcqdldSg3Bb4CW4C'
DSN = 'https://ejemplox.firebaseio.com'
EMAIL = '*****@*****.**'
authentication = FirebaseAuthentication(SECRET,EMAIL, True, True)
firebase = FirebaseApplication(DSN, authentication)
# Creamos un buble sin fin
while 1:
try:
# leemos hasta que encontarmos el final de linea
tupla = PuertoSerie.readline()
# Eliminamos el salto de linea del final
tupla= tupla.rstrip('\n')
time=datetime.datetime.now()
#print(time);
#dividir en ,
cadena=tupla.split(",")
data = {'humedad': int(cadena[0]),'proximidad':int(cadena[1]),'alcohol':int(cadena[2]),'luz':int(cadena[3]),'hora':time}
def update_firebase(path, key, data):
app = FirebaseApplication(settings.FIREBASE_URL)
app.put('{}/{}'.format(settings.FIREBASE_DB, path), key, data)
configure UART2. BB_UART.setup() enables UART2 a.k.a. /dev/ttyO2 on Beaglebone
"""
BB_UART.setup('UART2')
"""
Instantiate xbee module with uart serial port at 9600 baud
"""
ser = serial.Serial('/dev/ttyO2', 9600)
xbee = XBee(ser, escaped=True)
"""
configure firebase settings
"""
cf = config()
auth = FirebaseAuthentication(cf.firebaseSecret, cf.firebaseEmail, True, True)
fb = FirebaseApplication(cf.firebaseURL, auth)
"""
defined commands FROM sensor
"""
s_cmds = {
'Vegetronix': 'V',
'IR_Low': 'IL',
'IR_High': 'IH',
'IR_Sens': 'Se',
'IR_Slope': 'Sl',
'MLX_Std': 'M',
'MLX_Params': 'MP',
'MLX_Comp': 'MC',
'Pixel_Offset': 'PO',
'MLX_PTAT': 'Pt',
def post( url, data):
fb = FirebaseApplication('https://consulta-notas.firebaseio.com/', None)
response = fb.post(url, data, connection=None)
print response
def handle(self, **options):
admin_auth = FirebaseAuthentication(settings.FIREBASE['secret'],
'*****@*****.**',
admin=True)
app = FirebaseApplication(
settings.FIREBASE['base_url'],
authentication=admin_auth
)
offline_users = []
deletable_users = []
cleanup = app.put('cleanup', 'users', {'start': {'.sv': 'timestamp'},
'end': False})
start = cleanup['start']
logger.info("User cleanup started (force=%s) %d.", options['force'], start)
all_users = app.get('/', 'users') or {}
for uid, user in all_users.iteritems():
username = user.get('name').lower()
last_online = user.get('onlineAt', 0)
sessions = user.get('sessions', [])
session_age = (start - last_online) // 1000
if session_age > self.ONLINE_TIMEOUT:
if sessions:
logger.info("%s has been offline for %d seconds but appears online, "
"deleting online statuses...",
username, session_age)
offline_users.append(user)
elif options['force'] is True:
logger.info("%s has been offline for %d seconds and appears offline, "
"deleting possible online statuses anyway (because "
"force=True)",
username, session_age)
offline_users.append(user)
logger.debug('%s has been online for %d seconds', uid, session_age)
if session_age > self.OFFLINE_TIMEOUT:
logger.info("%s has been offline for %s seconds, deleting user...",
username, session_age)
deletable_users.append(user)
if deletable_users or offline_users:
org_ids_online = (app.get('/', 'organization-admins-online') or {}).keys()
org_keys = ['organization-admins-online/{}'.format(org_id)
for org_id in org_ids_online]
deletables = set()
for key in ['user-names-online', 'moderators-online', ] + org_keys:
usernames = (app.get('/', key) or {}).keys()
for user in offline_users + deletable_users:
deletable_username = user['name'].lower()
if deletable_username in usernames:
deletables.add((key, deletable_username))
for user in offline_users:
if user.get('sessions'):
deletables.add(('users/{}'.format(user['id']), 'sessions'))
deletables = list(deletables)
for u in deletable_users:
deletables.append(('users', u['id']))
for key, username in deletables:
logger.info('Deleting %s/%s', key, username)
app.delete(key, username)
end = app.put('cleanup/users', 'end', {'.sv': 'timestamp'})
logger.info("User cleanup ended %d.", end)
class FireAppEngineTestCase(unittest.TestCase):
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.setup_env(
app_id='your-app-id',
my_config_setting='example',
overwrite=True)
self.SECRET = 'FAKE_FIREBASE_SECRET'
self.DSN = 'https://firebase.localhost'
self.EMAIL = '*****@*****.**'
self.authentication = FirebaseAuthentication(self.SECRET, self.EMAIL,
None)
self.firebase = FirebaseApplication(self.DSN, self.authentication)
def tearDown(self):
self.testbed.deactivate()
def testEnvVars(self):
assert os.environ['APPLICATION_ID'] == 'your-app-id'
assert os.environ['MY_CONFIG_SETTING'] == 'example'
def test_build_endpoint_url(self):
url1 = os.path.join(self.DSN, 'users', '1.json')
self.assertEqual(self.firebase._build_endpoint_url('/users', '1'), url1)
url2 = os.path.join(self.DSN, 'users/1/.json')
self.assertEqual(self.firebase._build_endpoint_url('/users/1', None), url2)
def test_make_get_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.get('url', 'shapshot', params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
def test_make_post_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.post('url', {}, params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
def test_make_put_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.put('url', 'snapshot', {}, params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
def test_make_patch_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.patch('url', {}, params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
def test_make_delete_request(self):
response = MockResponse(403, json.dumps({'error': 'Permission required.'}))
connection = MockConnection(response)
result = self.firebase.delete('url', 'snapshot', params={}, headers={},
connection=connection)
self.assertEqual(result, json.loads(response.content))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
from firebase.firebase import FirebaseApplication, FirebaseAuthentication
if __name__ == '__main__':
SECRET = 'AXVwrDy1iXGlOgIF44itVhyOu7IswiMwttVtlVvd1'
DSN = 'https://geowa.firebaseio.com'
EMAIL = '*****@*****.**'
authentication = FirebaseAuthentication(SECRET,EMAIL, True, True)
firebase = FirebaseApplication(DSN, authentication)
firebase.get('/users', None,
params={'print': 'pretty'},
headers={'X_FANCY_HEADER': 'very fancy'})
data = {'name': 'Ozgur Vatansever', 'age': 26,
'created_at': datetime.datetime.now()}
snapshot = firebase.post('/users', data)
print(snapshot['name'])
def callback_get(response):
print response
firebase.get_async('/users', snapshot['name'], callback=callback_get)
def __init__(self):
self.delta = timedelta(seconds=app.config["CRONJOB_CYCLE"])
self.source_firebase = FirebaseApplication(app.config["FIREBASE_AIRPORT_DATE"], None)
self.dump_firebase = mapper.get_dump_firebase()
self.last_updated = parser.parse(self.dump_firebase.firebase.get("/", "last_updated"))
import datetime
from firebase.firebase import FirebaseApplication, FirebaseAuthentication
if __name__ == '__main__':
SECRET = 'ITC50GuznzevQBgZnOd3GPWtos2YkU0WrzS7ta7Z'
DSN = 'https://driquizo.firebaseio.com/'
EMAIL = '*****@*****.**'
# authentication = FirebaseAuthentication(SECRET,EMAIL, True, True)
firebase = FirebaseApplication(DSN, None)
snapshot = firebase.get('/quizzes', None,
params={'print': 'pretty'},
headers={'X_FANCY_HEADER': 'very fancy'})
print snapshot
# data = {'name': 'Ozgur Vatansever', 'age': 26,
# 'created_at': datetime.datetime.now()}
# snapshot = firebase.post('/quizzes', data)
# print(snapshot)
def callback_get(response):
with open('/dev/null', 'w') as f:
f.write(response)
firebase.get_async('/quizzes', snapshot, callback=callback_get)
def main(argv):
authentication = FirebaseAuthentication(SECRET,EMAIL, True, True)
firebase = FirebaseApplication(DSN, authentication)
result=firebase.get(PATH, None)
retrieveChatMessagesByTimestamp(result)
class AirportDelayRetriever:
def __init__(self):
self.delta = timedelta(seconds=app.config["CRONJOB_CYCLE"])
self.source_firebase = FirebaseApplication(app.config["FIREBASE_AIRPORT_DATE"], None)
self.dump_firebase = mapper.get_dump_firebase()
self.last_updated = parser.parse(self.dump_firebase.firebase.get("/", "last_updated"))
def get_flight_info_from_firebase(self):
response = self.source_firebase.get("", None)
updated = parser.parse(response["_updated"])
if updated <= self.last_updated + self.delta:
raise Exception("Not time to sync yet.")
print "Syncing Airpot Delays from", updated.isoformat()
self.last_updated = updated
update_str = updated.isoformat()
firebase_clean = FirebaseApplication(app.config["FIREBASE_CLEAN"], None)
for airport_code, info in response.items():
# this is not an airport :)
if airport_code == "_updated": continue
try:
self.dump_firebase.firebase.put(url="/"+airport_code, name=update_str, data=info)
filtered_data = utils.get_clean_data(info)
firebase_clean.put(url="/"+airport_code, name=update_str, data=filtered_data)
except Exception as e:
print "Something failed", e
self.dump_firebase.firebase.put("/", "last_updated", update_str)
def clean_data(self):
uncleaned = self.dump_firebase.get_all()
uncleaned = uncleaned or {}
firebase_clean = FirebaseApplication(app.config["FIREBASE_CLEAN"], None)
cleaned = firebase_clean.get("/", None)
for airport_code, date_status_dict in uncleaned.items():
if type(date_status_dict) != dict:
print airport_code, date_status_dict
continue
for date, event in date_status_dict.items():
if airport_code in cleaned and date in cleaned[airport_code]:
continue
filtered_data = utils.get_clean_data(event)
try:
firebase_clean.put(url="/"+airport_code, name=date, data=filtered_data)
print "Cleaned", airport_code, date
except Exception as e:
print "Could not clean", airport_code, date, event
print e
def run(self):
while True:
try:
self.get_flight_info_from_firebase()
except Exception as e:
print e
else:
print "Updated Info at", self.last_updated.isoformat()
time.sleep(app.config["CRONJOB_CHECK"])
