def validar_phone(self, phone):
try:
auth.get_user_by_phone_number('+57' + str(phone))
codigo = generador.validarGuardarInformacionError(
'000',
'validar telefono si existe - telefono si existe - validaciones',
'post', '')
return False, codigo
except:
return True, None
def get_user_by_phone_number():
phone = '+1 555 555 0100'
# [START get_user_by_phone]
from firebase_admin import auth
user = auth.get_user_by_phone_number(phone)
print('Successfully fetched user data: {0}'.format(user.uid))
def get_user(name):
"""Get a user by user ID or by email.
Args:
name (str): A user ID, email, or phone number.
Returns:
(Firebase user): A Firebase user object.
"""
user = None
try:
user = auth.get_user(name)
except:
pass
if user is None:
try:
user = auth.get_user_by_email(name)
except:
pass
if user is None:
try:
user = auth.get_user_by_phone_number(name)
except:
pass
return user
def login_user(phone, user_data=None):
try:
new_user = auth.create_user(phone_number=f'+{phone}')
# auth.cl client.collection.users
client = firestore.client()
collection = client.collection('users')
collection.add(
{
"avatarUrl": f'https://i.pravatar.cc/300?u={phone}',
"firstName": f"{phone}",
"lastName": ""
}, new_user.uid)
query_insert = f"INSERT INTO dictionary.users (id, phone, token_expired_at) VALUES ('{new_user.uid}', '{phone}', now() + interval '{TOKEN_LIVE_TIME}');"
result_execute_db_query(query=query_insert)
except (firebase_admin.auth.PhoneNumberAlreadyExistsError,
psycopg2.errors.UniqueViolation):
pass
except Exception as ex:
code = ex.__class__.__name__
message = ex
return {'body': None, 'code': code, 'message': message}
finally:
query = f"SELECT * FROM dictionary.users WHERE phone = '{phone}'"
user = result_execute_db_query(query=query, is_dict=True, fetch='one')
if user is None:
user = auth.get_user_by_phone_number(phone_number=f'+{phone}')
query_insert = f"INSERT INTO dictionary.users (id, phone, token_expired_at) VALUES ('{user.uid}', '{phone}', now() + interval '{TOKEN_LIVE_TIME}');"
result_execute_db_query(query=query_insert)
query_update = f"UPDATE dictionary.users SET token_expired_at = now() + interval '{TOKEN_LIVE_TIME}' WHERE phone = '{phone}'"
result_execute_db_query(query=query_update)
body = dict(
result_execute_db_query(query=query, is_dict=True, fetch='one'))
return {'body': body, 'code': None, 'message': None}
def get_or_create_firebase_test_user(phone_number, display_name=''):
try:
user = auth.get_user_by_phone_number(phone_number)
except UserNotFoundError:
user = auth.create_user(phone_number=phone_number,
display_name=display_name)
return user
def get_user_by_phone_number(phone):
"""
Returns a user object that is dictionary
of the user with attributes:
display_name , email , password, phone_number
"""
from firebase_admin import auth
try:
user = auth.get_user_by_phone_number(phone)
doc = db.collection(u'users').document(user.uid)
doc = doc.get().to_dict()
return doc
except firebase_admin._auth_utils.UserNotFoundError as ex:
from Pages.UserAuthentication.Exceptions import User_not_Found
User_not_Found()
return False
except Exception as ex:
messagebox.showerror(
'Error', 'Oops!! Something went wrong!!\nTry again later.')
print('Exception Occurred which is of type :', ex.__class__.__name__)
y = input('If you want to see Traceback press 1 : ')
if y == '1':
traceback.print_exc()
return False
def get(
self,
# define one of the following parameters.
uid=None,
email=None,
phone_number=None,
):
try:
user, variable = None, None
if uid not in [None, "None", ""]:
user = auth.get_user(uid)
variable = str(uid)
elif email not in [None, "None", ""]:
user = auth.get_user_by_email(email)
variable = str(email)
elif phone_number not in [None, "None", ""]:
user = auth.get_user_by_phone_number(phone_number)
variable = str(phone_number)
else:
return dev0s.response.error(
"Invalid usage, define one of the following parameters: [uid, email, phone_number]."
)
except _auth_utils.UserNotFoundError:
return dev0s.response.error("User does not exist.")
# check success.
if user == None:
return dev0s.response.error(
f"Failed to retrieve user [{variable}].")
else:
return dev0s.response.success(
f"Successfully retrieved user [{variable}].", {"user": user})
def get_user_by_phone(self, phone: str):
logger.info(f"Searching for phone {phone}")
user = auth.get_user_by_phone_number(phone)
if user:
logger.info(f"User with phone {phone} not found")
document = {"fuid": user.uid}
return document
else:
logger.info(f"User with phone {phone} found")
return None
def get_claim(self):
# Verify Firebase auth.
id_token = request.cookies.get("token")
error_message = None
claims = None
times = None
if id_token:
try:
# Verify the token against the Firebase Auth API. This example
# verifies the token on each page load. For improved performance,
# some applications may wish to cache results in an encrypted
# session store (see for instance
claims = google.oauth2.id_token.verify_firebase_token(id_token, google_requests.Request())
if 'current_user' not in self.session:
self.session['current_user'] = dict()
sign_in_provider = claims['firebase']['sign_in_provider']
if sign_in_provider == 'phone':
self.store_time(claims['phone_number'], datetime.datetime.now())
times = self.fetch_times(claims['phone_number'], 10)
userInfo = auth.get_user_by_phone_number(claims['phone_number'])
else:
self.store_time(claims['email'], datetime.datetime.now())
times = self.fetch_times(claims['email'], 10)
userInfo = auth.get_user_by_email(claims['email'])
self.session['claims'] = claims
self.session['current_user']['uid'] = userInfo.uid
self.session['current_user']['phone_number'] = userInfo.phone_number
self.session['current_user']['email'] = userInfo.email
self.session['current_user']['provider_id'] = userInfo.provider_id
self.session['current_user']['disabled'] = userInfo.disabled
self.session['current_user']['tokens_valid_after_timestamp'] = userInfo.tokens_valid_after_timestamp
self.session['current_user']['creation_timestamp'] = userInfo.user_metadata.creation_timestamp
self.session['current_user']['last_sign_in_timestamp'] = userInfo.user_metadata.last_sign_in_timestamp
self.session['current_user']['provider_data'] = userInfo.provider_data
self.session['current_user']['custom_claims'] = userInfo.custom_claims
self.session['current_user']['tenant_id'] = userInfo.tenant_id
except ValueError as exc:
# This will be raised if the token is expired or any other
# verification checks fail.
error_message = str(exc)
return claims, times, error_message
def test_get_user(new_user_with_params):
user = auth.get_user(new_user_with_params.uid)
assert user.uid == new_user_with_params.uid
assert user.display_name == 'Random User'
assert user.email == new_user_with_params.email
assert user.phone_number == new_user_with_params.phone_number
assert user.photo_url == 'https://example.com/photo.png'
assert user.email_verified is True
assert user.disabled is False
user = auth.get_user_by_email(new_user_with_params.email)
assert user.uid == new_user_with_params.uid
user = auth.get_user_by_phone_number(new_user_with_params.phone_number)
assert user.uid == new_user_with_params.uid
assert len(user.provider_data) == 2
provider_ids = sorted([provider.provider_id for provider in user.provider_data])
assert provider_ids == ['password', 'phone']
def login_by_phone(request):
if request.POST:
phone = request.POST.get('mob')
password = request.POST.get('password')
print("****************************************")
user_phone = admin.get_user_by_phone_number(phone)
name = (user_phone.display_name)
try:
user = authe.sign_in_with_email_and_password(user_phone.email, password)
except:
messsage = "invalid credentials"
return render(request, "signIn.html", {'messsage': messsage})
user_phone = authe.get_account_info(user['idToken'])
print(user_phone)
user_phone = user_phone['users'][0]['phoneNumber']
# print(user_phone['users'][0]['displayName'])
if user_phone == phone:
session_id = user['idToken']
request.session['uid'] = str(session_id)
request.session['user_phone'] = str(user_phone)
# try :
if user_phone == "+919922716485":
return render(request, "index.html" ,{'name':name})
else:
# return render(request, "farmer_dashboard.html" ,{'name':name})
# except:
data = database.child('users').child("Farmers").child(user_phone).child("Produce-Request").get().val()
li = []
for key, value in data.items():
temp = [ key ,value['Buyer'] ,database.child('users').child("Buyers").child(value['Buyer']).child("Name").get().val() ]
li.append(temp)
temp=[]
print(key, value['Buyer'] , database.child('users').child("Buyers").child(value['Buyer']).child("Name").get().val())
print("555555555555555555")
# print(temp)
return render(request, "farmer_dashboard.html" ,{'name':name , 'Buyer_List' : li })
def test_invalid_get_user_by_phone(self, arg):
with pytest.raises(ValueError):
auth.get_user_by_phone_number(arg)
def test_get_user_by_phone(self, user_mgt_app):
_instrument_user_manager(user_mgt_app, 200, MOCK_GET_USER_RESPONSE)
_check_user_record(
auth.get_user_by_phone_number('+1234567890', user_mgt_app))
def create(phone: str):
try:
user = auth.get_user_by_phone_number(phone_number=phone)
except auth.UserNotFoundError:
user = auth.create_user(phone_number=phone)
print('Sucessfully created new user: {0}'.format(user.uid))
def check_firebase_uid(phone_number, uid):
try:
user = auth.get_user_by_phone_number(phone_number)
return user.uid == uid
except UserNotFoundError:
return False
def test_get_user_by_phone(self, user_mgt_app):
_instrument_user_manager(user_mgt_app, 200, MOCK_GET_USER_RESPONSE)
_check_user_record(
auth.get_user_by_phone_number(self.VALID_PHONE, user_mgt_app))
def test_get_user_by_phone_http_error(self, user_mgt_app):
_instrument_user_manager(user_mgt_app, 500, '{"error":"test"}')
with pytest.raises(auth.AuthError) as excinfo:
auth.get_user_by_phone_number(self.VALID_PHONE, user_mgt_app)
assert excinfo.value.code == _user_mgt.INTERNAL_ERROR
assert '{"error":"test"}' in str(excinfo.value)
"chairman",
"vice_chairman",
"finance",
"operations"
]
officer_roles = [
"communications",
"publicity",
"executive",
"finance",
"operations"
]
user_lookup_methods = {
"phone": lambda phone: [firebase_auth.get_user_by_phone_number(phone if "+" in phone else "+1" + phone)],
"email": lambda email: [firebase_auth.get_user_by_email(email)],
"name": lambda name: [firebase_auth.get_user(user.id) for user in fireClient.collection("users").where("name_array", "array_contains_any", name.lower().split()).stream()]
}
def is_verified(uid):
try:
firebase_auth.get_user(uid)
except:
return False
try:
return fireClient.collection("users").document(uid).get().get("tier") == "director"
except:
return False
@info.route("/")
