def find_by_id(self, id):
print('PatienceRepository:get_by_id::' + id)
db = firestore.client()
doc = db.collection(u'patiences').document(id)
print('---------->' + str(doc.get().to_dict()))
return doc.get().to_dict()
def put(self, object):
try:
print('PatienceRepository:put::Atualizando...' + object.get('id'))
db = firestore.client()
doc_ref = db.collection(u'patiences').document(object.get('id'))
doc = doc_ref.get()
doc_ref.update({
u'first': object.get('first_name'),
u'last': object.get('last_name'),
u'email': object.get('email'),
u'cpf': object.get('cpf')
})
print('PatienceRepository:put::salvo...')
return doc_ref.get().to_dict()
except google.cloud.exceptions.NotFound:
print(u'Identificador não encontrado.')
raise ValueError('Identificador {} não encontrado.'.format(
object.get('id')))
except ValueError as error:
print('PatienceRepository:put::erro...' + str(error))
raise
def download_faces():
config = {
"apiKey": "AIzaSyC2AMehEW9xsxtLdVKHzZG7ENNh2wrBNw0",
"authDomain": "mspi-a4b75.firebaseapp.com",
"databaseURL": "https://mspi-a4b75.firebaseio.com",
"storageBucket": "mspi-a4b75.appspot.com",
}
storage_client = firestore.client()
firebase = pyrebase.initialize_app(config)
storage = firebase.storage()
#Query for familiarFaces name array from user in Firebase
user_collection = storage_client.collection('users')
results = user_collection.document(settings.userID).get()
faces = results.to_dict().get('familiarFaces')
#Download those faces from firbase storage
if faces:
for face in faces:
storage.child(settings.userID + "/Training/" + face).download(
"/home/pi/Desktop/CameraSoftware/familiarFaces/" + face)
else:
print("No Faces")
def get_admin():
db = firestore.client()
doc_ref = db.collection('admin')
docs = doc_ref.stream()
temp = {}
for doc in docs:
temp = doc.to_dict()
return temp
def Upload(tmp, DocumentID):
db = firestore.client()
doc_ref = db.collection(DocumentID)
if (DocumentID == "DateTime"):
p = {'id': 0}
doc_ref.document(str(date.today())).set(p)
doc_ref = db.collection(u"DateTime").document(str(
date.today())).collection("Authorised")
doc_ref.document(tmp['User_ID']).set(tmp)
#list(map(lambda x: doc_ref.document(x['User_ID']).set(x), tmp))
else:
doc_ref.document(tmp['User_ID']).set(tmp)
def find_all(self):
users = []
print('PatienceRepository:findAll::')
db = firestore.client()
docs = db.collection(u'patiences').stream()
for doc in docs:
users.append(doc.to_dict())
print('PatienceRepository:findAll::qtde::' + str(len(users)))
return users
def __init__(self):
# Login with your Firestore credentials
cred = credentials.Certificate(
'/home/dstaflund/security/gcp/nts-lookup/nts-lookup-257217-b5508fea7e97.json'
)
self.db_admin = firebase_admin.initialize_app(cred)
self.db = firestore.client()
# My sample DB
with open(
'/home/dstaflund/AndroidStudioProjects/nts-lookup/gcp/firestore/maps.json',
'r') as f:
self.maps_db = json.load(f)
def yaziGonder(request):
db = firestore.client()
baslik = request.POST.get('baslik')
icerik = request.POST.get('icerik')
doc_ref = db.collection(baslik).document(baslik)
doc_ref.set({
"Baslık": baslik,
"Icerik": icerik,
"Tarih": firestore.SERVER_TIMESTAMP,
})
return render(request, 'templates/yazi.html')
def get_data(User_ID, DocumentID):
db = firestore.client()
doc_ref = db.collection(DocumentID)
docs = doc_ref.stream()
Time = []
Date = 0
image = ""
password = ""
for doc in docs:
temp = doc.to_dict()
if (User_ID == temp['User_ID']):
Time = (temp['Time'])
Date = temp['Date']
image = temp['Image']
password = temp['Password']
return Time, Date, image, password
def __init__(self):
envData = environment.Data()
pyrebaseConfig = envData.config['pyrebaseConfig']
localCredentials = credentials.Certificate(pyrebaseConfig['serviceAccount'])
firebase_admin.initialize_app(localCredentials)
self.database = firestore.client()
self.artistReference = self.database.collection(u'artist_q')
self.trackReference = self.database.collection(u'track_q')
self.trackConfig = envData.config['databaseConfig']['track_q']['track_id']
self.search = sp_search.sp_search()
self.market = envData.config['crawlerConfig']['markets']
self.read_input()
def __init__(self):
self.egitimBaslik = []
self.egitimLink = []
self.egitimFotograf = []
self.egitimAciklama = []
self.egitimFiyat = []
self.egitimVeren = []
import firebase_admin
from firebase_admin import credentials
from firebase_admin import firestore
# Use the application default credentials
cred = credentials.ApplicationDefault()
cred = credentials.Certificate('pythondeneme-14e92-44e0170fe986.json')
firebase_admin.initialize_app(cred)
self.db = firestore.client()
def get_check_email_exists(self, email):
try:
print('PatienceRepository:get_check_email_exists::')
db = firestore.client()
docs = db.collection(u'patiences').where(u'email', u'==',
email).stream()
my_dict = {el.id: el.to_dict() for el in docs}
if len(my_dict) > 0:
raise ValueError(
'O E-mail {} já está cadastrado.'.format(email))
except google.cloud.exceptions.NotFound:
print('PatienceRepository:get_check_email_exists::NotFound...')
return None
except ValueError as error:
raise
def __init__(self):
self.DC = []
self.DCname = []
self.DCavatar = []
self.DClink = []
self.DCbio = []
self.DCauthor = []
cred = credentials.Certificate(
'pdf-kitaplar-firebase-adminsdk-p2r3c-5cebe0c664.json')
firebase_admin.initialize_app(cred)
self.db = firestore.client()
self.browser = webdriver.Chrome(
executable_path=f"C:\\Program Files (x86)\\Google\\chromedriver.exe"
)
self.browser.maximize_window()
def post(self, object):
try:
print('PatienceRepository:post::Salvando...')
self.get_check_email_exists(object.get('email'))
db = firestore.client()
id = uuid.uuid4()
doc_ref = db.collection(u'patiences').document(str(id))
doc_ref.set({
u'id': str(id),
u'first': object.get('first_name'),
u'last': object.get('last_name'),
u'email': object.get('email'),
u'cpf': object.get('cpf')
})
print('PatienceRepository:post::salvo...')
return doc_ref.get().to_dict()
except ValueError as error:
print('PatienceRepository:post::erro...' + str(error))
raise
def __init__(self):
env_data = environment.Data()
self.crawler_config = env_data.config['crawlerConfig']
self.init_artists = json.load(open(self.crawler_config['initArtists']))
self.artist_config = env_data.config['databaseConfig']['artist_q'][
'artist_id']
pyrebase_config = env_data.config['pyrebaseConfig']
cred = credentials.Certificate(pyrebase_config['serviceAccount'])
firebase_admin.initialize_app(cred)
self.db = firestore.client()
self.config = env_data.config['crawlerConfig']
self.search = sp_search.sp_search()
self.rerun = False
self.rerun_init_time = datetime.datetime.now()
def yazilar(request):
db = firestore.client()
docs = db.collection(u'Yazı Deneme Part 5').stream()
for doc in docs:
values1 = doc.to_dict()
baslik1 = values1.get('Baslık')
icerik1 = values1.get('Icerik')
a = (f"{time.strftime('%X')}")
doc_ref = db.collection(u'FireStore Yazı').stream()
for doc in doc_ref:
values = doc.to_dict()
baslik = values.get('Baslık')
icerik = values.get('Icerik')
doc_ref = db.collection(u'Yazı Deneme 7').stream()
for doc in doc_ref:
values2 = doc.to_dict()
baslik2 = values2.get('Baslık')
icerik2 = values2.get('Icerik')
context = {
"a": a,
"baslik": baslik,
"icerik": icerik,
"baslik1": baslik1,
"baslik2": baslik2,
"icerik1": icerik1,
"icerik2": icerik2
}
return render(request, 'templates/yazılar.html', context)
from bluepy.btle import Scanner, DefaultDelegate
from google.cloud import firestore
import datetime
import firebase_admin
import time
import os
from firebase_admin import credentials
from firebase_admin import firestore
cred = credentials.Certificate("/home/pi/hack/beacons/cred.json")
firebase_admin.initialize_app(cred, {'projectId': 'test-215901'})
db = firestore.client()
def insert_data(db, mac, distance):
ts = time.time()
timestamp = datetime.datetime.fromtimestamp(ts).strftime(
'%Y-%m-%d %H:%M:%S')
doc_ref = db.collection(u'devices').document(mac)
doc_ref.set({u'distance': distance, u'timestamp': timestamp})
class ScanDelegate(DefaultDelegate):
def __init__(self):
DefaultDelegate.__init__(self)
def handleDiscovery(self, dev, isNewDev, isNewData):
if isNewDev:
print("Discovered device", dev.addr)
portExtra = "/dev/ttyUSB1"
endian = 'little'
config = {
"apiKey": "AIzaSyDXqpsFQ8vHNvmxOMEON3L_zPmPWUZOzlo",
"authDomain": "fitbyte-fitbyte.firebaseapp.com",
"databaseURL": "https://fitbyte-fitbyte.firebaseio.com",
"storageBucket": "fitbyte-fitbyte.appspot.com"
}
firebase = pyrebase.initialize_app(config)
cred = credentials.Certificate(
'./fitbyte-fitbyte-firebase-adminsdk-s6905-6104a6607a.json')
fs = firebase_admin.initialize_app(cred)
db = firebase.database()
db_FireStore = firestore.client()
beams_client = PushNotifications(
instance_id='a194b3e8-beab-4ceb-a831-4f3b45eddc96',
secret_key=
'209B915E1261D6CDC828F9296D35F5A413D738E08D0D514A3E4B83E5E60668BC',
)
total_accl = [] # List of two acceleration values.
alert_state = 0 # state (0/1) says whether to be alert and start counting the switches or be relaxed.
change = 0 # Single value representing switch nature.
switches = 0 # Measure of number of tremors.
cautious_state = 0 # State 1 or 0 indicating whether the system needs to enter cautious state or not.
switch_nature = []
switch_sample = []
# firebase service.json
#
}
# Check API keys
if (len(WEB_API_KEY) == 0 or len(SERVER_CONFIG) == 0):
print("Incorrect WEB_API_KEY, SERVER_CONFIG")
exit(0)
# initialized using secret json
print("- - - app init - - - ")
cred = credentials.Certificate(SERVER_CONFIG)
firebase_admin.initialize_app(cred)
# create a firestore client
db_ref = firestore.client()
app = Flask(__name__)
#--------------------------------#
# User Manager #
#--------------------------------#
# /user/signUp #
# send_verify_email() #
# /user/login #
# /user/tokenVerify #
# retrieve_new_id_token() #
# /user/connectedNodes #
# /user/setFCMToken #
# /user/profileInfo/update #
def init():
#Initializer
#--------------------------------------------------------------------------------------------------#
#Starting FireStore
cred = credentials.Certificate('/home/pi/Desktop/CameraSoftware/cred.json')
#cred=credentials.Certificate('cred.json')
app = firebase_admin.initialize_app(
cred, {'storageBucket': 'mspi-a4b75.appspot.com'})
storage_client = firestore.client()
#--------------------------------------------------------------------------------------------------#
#Globals
global lock
global unlock
global cameraID
global known_face_encodings
global known_face_names
global userID
global active
global ready
#--------------------------------------------------------------------------------------------------#
#Set Globals
cameraID = "00123"
lock = False
unlock = True
known_face_encodings = []
#Get UserID
user_collection = storage_client.collection('users')
results = user_collection.where('cameraIds', u'array_contains',
cameraID).get()
for item in results:
userID = item.id
#Download Faces to Be Recognized
download_faces()
#print("Faces Downloaded!")
#Clear WebRTC
web_rtc_col = storage_client.collection('webrtctest')
to_be_deleted = web_rtc_col.where(u'sender', u'==', cameraID).get()
lala = firebase.FirebaseApplication(
'https://https://mspi-a4b75.firebaseio.com', None)
for item in to_be_deleted:
storage_client.collection(u'webrtctest').document(item.id).delete()
#Camera is not Active -> Alerts database that camera is not ready for use
active = False
camera_collection = storage_client.collection('cameras')
document = camera_collection.document(cameraID)
field_updates = {"active": False}
document.update(field_updates)
#Camera is not Ready -> Alerts database that camera is not ready for use
ready = False
field_updates = {"ready": False}
document.update(field_updates)
#--------------------------------------------------------------------------------------------------#
#Train Face data models
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
image_dir = os.path.join(BASE_DIR, 'familiarFaces')
labels = []
paths = []
#Loop through all images in directory
for root, dirs, files in os.walk(image_dir):
for file in files:
if file.endswith("png") or file.endswith("jpg") or file.endswith(
"JPG"):
path = os.path.join(root, file)
#label comes from file name
label = file.split(".")[0]
paths.append(path)
labels.append(label)
#Open Images and create encodings
#loop through Names and add them to known_face_names
for i in range(0, len(paths)):
tempImage = face_recognition.load_image_file(paths[i])
tempEncoding = face_recognition.face_encodings(tempImage)[0]
known_face_encodings.append(tempEncoding)
known_face_names = labels
#--------------------------------------------------------------------------------------------------#
#Set Ready = True on db
ready = True
camera_collection = storage_client.collection('cameras')
document = camera_collection.document(cameraID)
field_updates = {"ready": True}
document.update(field_updates)
#Create Doc on database webrtctest
data = {u'sender': cameraID, u'what': u'unlock'}
storage_client.collection(u'webrtctest').document().set(data)
def delete(self, id):
print('PatienceRepository:delete::' + id)
db = firestore.client()
db.collection(u'patiences').document(id).delete()
