def create_user(self, uemail, upassword, uname, db, msg=None):
try:
doc = db.collection(u'users').document(uname).get()
if doc.exists:
raise auth._auth_utils.EmailAlreadyExistsError(
message="The username provided already exists",
cause=None,
http_response=None)
else:
auth.get_user_by_email(uemail)
raise auth._auth_utils.EmailAlreadyExistsError(
message="The email provided already exists",
cause=None,
http_response=None)
except auth._auth_utils.UserNotFoundError:
user = auth.create_user(
email=uemail,
email_verified=False,
password=upassword,
display_name=uname,
)
session['email'] = user.email
session['uid'] = user.uid
session['uname'] = user.display_name
except auth._auth_utils.EmailAlreadyExistsError:
msg = "The username/email you entered already exists in our database."
except ValueError:
msg = "Your password has to be atleast 6 characters."
return msg
def test_get_user_by_email_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_email('*****@*****.**',
user_mgt_app)
assert excinfo.value.code == _user_mgt.INTERNAL_ERROR
assert '{"error":"test"}' in str(excinfo.value)
def login(request):
global post_register_message, post_top_message, full_name
authD.logout(request)
if request.method == 'POST':
form = forms.LoginForm(request.POST)
if form.is_valid():
Email = form.cleaned_data[
'Email'] #the "Email" string needs to match to the name of the variable in the forms.py file (it gets the data from that file)
pwd = form.cleaned_data[
'pwd'] #the "pwd" string needs to match to the name of the variable in the forms.py file (it gets the data from that file)
try:
pyrebase_auth = pyrebase.auth()
user = pyrebase_auth.sign_in_with_email_and_password(
Email, pwd)
usuario = auth.get_user_by_email(Email)
full_name = usuario.custom_claims.get(
'First_name') + ' ' + usuario.custom_claims.get(
'Last_name')
except:
return_message = 'Invalid login credentials. Try again.'
return render(request, 'plotlyapp/login.html',
{'message': return_message})
user_for_uid = auth.get_user_by_email(Email)
account = firebase_admin.auth.get_user(user_for_uid.uid)
if account.email_verified == True:
session_id = user['idToken']
request.session['uid'] = str(
session_id
) #Request session key for authentication in all pages
if request.session.has_key(
'uid'): #If it has key, send to main page
return redirect(welcome)
else:
return render(request, 'plotlyapp/login.html')
else:
return_message = 'Please verify your email account address first'
return render(request, 'plotlyapp/login.html',
{'message': return_message})
else:
print('Not a valid form')
else:
form = forms.LoginForm()
if post_register_message == False and post_top_message == False:
return render(request, 'plotlyapp/login.html')
elif post_register_message != False and post_top_message == False:
message = {'post_register_message': post_register_message}
post_register_message = False
return render(request, 'plotlyapp/login.html', message)
elif post_register_message == False and post_top_message != False:
message = {'post_register_message': post_top_message}
post_top_message = False
return render(request, 'plotlyapp/login.html', message)
else:
return render(request, 'plotlyapp/login.html')
def validar_email(self, email):
try:
auth.get_user_by_email(email)
codigo = generador.validarGuardarInformacionError(
'000',
'validar email si existe - email si existe - validaciones',
'post', '')
return False, codigo
except Exception as a:
print(a)
return True, None
def del_user(self,email,passw):
try:
user = auth.get_user_by_email(email.get())
auth.delete_user(user.uid)
self.__gui.show_msg_monitor(">> Successfully deleted user", "success")
except:
self.__gui.show_msg_monitor(">> user not exsist", "error")
def SignUp(request):
if request.method == 'POST':
name = request.POST.get('name')
age = int(request.POST.get('age'))
email = request.POST.get('email')
gender = request.POST.get('gender')
password = request.POST.get('password')
#timestamp = time.mktime(time.strptime("%B %d, %Y - %H:%M:%S",timezone.now()))
#print(app.name())
user = auth.create_user(email=email,
password=password,
display_name=name,
app=appsign)
print(user.uid)
try:
user_correct = auth.get_user_by_email(email, app=appsign)
except:
message = "회원 등록에 실패했습니다."
return render(request, "SignUp.html", {"message": message})
print(user_correct.uid)
data.Add_User_Store(user.uid, name, age, email, gender)
auth.set_custom_user_claims(user.uid, {u'admin': False})
#UserAdd
return redirect("SAccount:signin")
else:
return render(request, "SignUp.html")
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():
session.pop('user', None)
login_email = request.form['email']
login_password = request.form['password']
login_check = request.form['login_check']
if not login_email or not login_password:
return jsonify({'err_msg': 'Login failed!'}), 401
try:
user = User.query.filter_by(email=login_email).first()
except:
return jsonify({'err-msg': 'Do not exit input email'})
if check_password_hash(user.password, login_password):
user = auth.get_user_by_email(login_email)
custom_token = (auth.create_custom_token(user.uid)).decode()
# create session
session['user'] = login_email
return jsonify({'token': custom_token})
return jsonify({'err-msg': 'Confirm your email or password'}), 401
def create_chatroom(self, request):
firestore_db = firestore.client()
bot_uid = '{}-{}'.format(request.data['language'], request.data['gender'])
current_user = auth.get_user_by_email(request.user.email)
chatroom_data = {
'last_message': {
'sent_by': '',
'sent_at': '',
'text': '',
},
'language': request.data['language'],
'members_uids': [bot_uid, current_user.uid],
'members': {
bot_uid: {
'full_name': request.data['name']
},
current_user.uid: {
'full_name': '{} {}'.format(request.user.first_name, request.user.last_name)
}
}
}
firestore_db.collection('chatrooms').add(chatroom_data)
return Response({
'status': 'ok'
})
def login():
if request.method == 'POST':
login_kisan = Login()
data, email = login_kisan.kisan_login()
print(data)
print(type(data))
if data == 'successful':
user = auth.get_user_by_email(email)
print('Successfully fetched user data: {0}'.format(user.uid))
doc_ref = db.collection(u'users').document(
u'a5V6A27Y0CS1YuA6MMoFJvHxutc2')
docs = doc_ref.get().to_dict()
print(docs)
print(user.uid)
return render_template('kisan_profile.html',
data=docs,
display=False,
user_id=user.uid)
else:
flash(
f'Login Failed Please check Your Kisan ID Number and Password',
'danger')
return redirect('/login')
return render_template('login.html')
def get_user_by_email(email):
"""
Returns a user object that is dictionary
of the user with attributes:
display_name , email , password, phone_number
"""
# [START get_user_by_email]
import firebase_admin
from firebase_admin import auth
try:
user = auth.get_user_by_email(email)
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 login_user():
json_get = bottle.request.json
email = json_get.get("email")
password = json_get.get("password")
validate_tuteria = json_get.get("validate_server")
if email and password:
if validate_tuteria:
result = get_agent_details(email, password)
if result:
user = get_or_create_user_from_firebase(result, password)
else:
abort(400, "Not Authorized")
else:
try:
user = auth.get_user_by_email(email)
except firebase_admin.auth.AuthError:
abort(400, "Not Authorized")
token = auth.create_custom_token(user.uid).decode()
return {
"token": token,
"details": {
"display_name": user.display_name,
"uid": user.uid,
"email": user.email,
},
}
abort(400, "The credentials passed are invalid")
def login_page():
error = ''
try:
if request.method == "POST":
jsonReq = request.get_json()
print(jsonReq)
email = jsonReq['email']
password = jsonReq['password']
body = {'email': email, 'password': password}
params = {'key': public_config.FIREBASE_API_KEY}
resp = requests.request('post',
_verify_password_url,
params=params,
json=body)
if bool(resp.json().get('registered')):
user = auth.get_user_by_email(email)
return json.jsonify({
'success': 1,
'email': user.email,
'name': user.display_name,
'uid': user.uid
})
else:
return json.jsonify({'success': 0})
return json.jsonify({'success': 0})
except Exception as e:
#flash(e)
print("error: " + str(e))
return json.jsonify({'success': 0})
def post(self, request, *args, **kwargs):
form = FeedbackForm(request.POST)
if form.is_valid():
feedback = form.save(commit=False)
try:
uid = auth.get_user_by_email(feedback.email).uid
feedback = feedback.__dict__
for key in {'_state', 'id'}:
feedback.pop(key)
feedback.update({
'date_time':
feedback.get('date_time').strftime('%d_%m_%Y %H:%M:%S')
})
database.child('feedback').child(uid).child(
str(feedback.get('email')).replace('.', ',')).set(feedback)
alert = "Your Feedback is Recorded Successfully! We will contact you in few days"
error = False
except auth.AuthError:
database.child('feedback').child('anonymous').child(
str(feedback.email).replace('.', ',')).set(feedback)
alert = "Your Feedback is Recorded Successfully"
error = False
else:
alert = "Enter Valid Details"
error = True
return JsonResponse({'alert': alert, 'error': error})
def delete_user(request):
email = request.args.get('email')
u_id = request.args.get('id')
c_user = request.args.get('user')
try:
user_info = users.where('email', '==',
c_user).limit(1).get()[0].to_dict()
if user_info['admin']:
user = f_auth.get_user_by_email(email)
users.document(u_id).delete()
f_auth.delete_user(user.uid)
# TODO: do recursive delete of files related to the user
return {'id': u_id}
else:
return {'error': f"You dont have permissions", 'status_code': 490}
except Exception as e:
import traceback
traceback.print_exc()
print(e)
return {
'error': f"unable to delete file SEVER ERROR",
'status_code': 490
}
def deleteUser():
response = ''
email = ((request.args.get('email')))
user = auth.get_user_by_email(email)
auth.delete_user(user.uid)
print(response)
return ("Ok" + response)
def activateUser():
response = ''
email = ((request.args.get('email')))
user = auth.get_user_by_email(email)
auth.update_user(user.uid, disabled=False)
print(response)
return ("Ok" + response)
def process_view(self, request, view_func, view_args, view_kwargs):
if request.path != '/mcc/user/' or request.method != 'POST':
cred = credentials.Certificate(
os.path.join(settings.BASE_DIR, 'key.json'))
try:
email = request.headers['X-Authorization-Email']
uuid = request.headers['X-Authorization-UUID']
except Exception as e:
return JsonResponse(
{
"success": "false",
"error": "RequestHeadersNotFound"
},
status=401)
try:
user = auth.get_user_by_email(email)
except Exception as e:
return JsonResponse(
{
"success": "false",
"error": "UserNotFound"
}, status=401)
if user.uid != uuid:
return JsonResponse(
{
"success": "false",
"error": "InvalidAuthorizationHeader"
},
status=401)
def authenticate(email: str, password: str):
""" User login process"""
try:
user = auth.get_user_by_email(email)
if user.email_verified != True:
return {
"message":
"Email is not verified, Please verify email first"
}, 400
except Exception as e:
return {"message": e.args[0]}, 400
json_string = {
"email": email,
"password": password,
"returnSecureToken": True
}
API_KEY = environ.get('API_KEY')
url = 'https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=' + API_KEY
res = requests.post(url, data=json_string)
json_response = json.loads(res.text)
if "error" in json_response.keys():
error_message = json_response["error"]
if error_message["message"] == "INVALID_PASSWORD":
return {"message": "Password is incorrect"}, 401
else:
return {"message": error_message["message"]}, 401
return json_response, 200
def get_answers(*args, **kwargs):
user = auth.get_user_by_email('*****@*****.**')
answers = db.answers \
.find({'user_id': user.uid}) \
.sort('_id', -1) \
.limit(1)
return jsonify(AnswerSchema().dump(answers, many=True)), 200
def get_students():
try:
email = request.args.get('email')
if email is not None:
# Just a single user by email: accessibly publicly
if is_admin(email):
return jsonify({'email': email, 'is_admin': True})
student = ClassSectionStudent.query.filter_by(email=email).first()
if student is not None:
# Get the firebase user information
data = student.serialize()
try:
firebase_user = auth.get_user_by_email(email)
data['signed_up'] = True
except:
data['signed_up'] = False
data['is_admin'] = False
return jsonify(data)
else:
return error(404, message='This student does not exist.')
else:
# To fetch all users: must be an admin
try:
verify_admin()
except Exception as e:
return error(403, error=e)
students = ClassSectionStudent.query.all()
return jsonify([s.serialize() for s in students])
except Exception as e:
print(str(e))
return error(error=e)
def kisan_center():
if request.method == 'POST':
login_kisan = Login_Kisan()
data, email = login_kisan.kisan_center_login()
print(data)
print(type(data))
if data == 'successful':
user = auth.get_user_by_email(email)
print('Successfully fetched user data: {0}'.format(user.uid))
doc_ref = db.collection(u'users').document(u'' + user.uid)
docs = doc_ref.get().to_dict()
print(docs)
print(user.uid)
return render_template('kisan_center.html',
data=False,
error=False)
else:
flash(
f'Login Failed Please check Your Kisan ID Number and Password',
'danger')
return redirect('/kisan_center')
return render_template('kisan_login.html')
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_email():
email = '*****@*****.**'
# [START get_user_by_email]
from firebase_admin import auth
user = auth.get_user_by_email(email)
print('Successfully fetched user data: {0}'.format(user.uid))
def main(is_uid, users):
# client = Client(project=config.project_id)
creds_path = os.path.join(
os.environ.get('BIKEBUDS_ENV'),
'service_keys/firebase-adminsdk.json',
)
client = Client.from_service_account_json(creds_path)
for u in users:
logging.info('Deleting: %s', u)
if is_uid:
uid = u
else:
logging.info('Looking up: %s', u)
uid = auth.get_user_by_email(u).uid
try:
key = client.key('User', uid)
if client.get(key) is not None:
children_query = client.query(ancestor=key)
children_query.keys_only()
client.delete_multi(child.key for child in children_query.fetch())
else:
logging.warning('Could not cleanup datastore for: %s', u)
except Exception:
logging.warning('Could not delete datastore user: %s', u)
try:
auth.delete_user(uid)
except auth.UserNotFoundError:
logging.warning('Could not delete firebase user: %s', u)
pass
def setChipID(self, chipID, email):
self.refreshDB()
if not chipID in self.devicesData:
user = auth.get_user_by_email(email)
print(user.uid)
self.devicesData[chipID] = user.uid
self.updateDB()
def email_available(email):
try:
user = auth.get_user_by_email(email)
except Exception as e:
if (e.code == 'USER_NOT_FOUND_ERROR'):
return True
return False
def set_custom_user_claims_script():
# [START set_custom_user_claims_script]
user = auth.get_user_by_email('*****@*****.**')
# Confirm user is verified
if user.email_verified:
# Add custom claims for additional privileges.
# This will be picked up by the user on token refresh or next sign in on new device.
auth.set_custom_user_claims(user.uid, {'admin': True})
def get_user(self, **kwargs):
uid = kwargs.get('id', None)
if uid:
return auth.get_user(app=self.app, uid=uid)
email = kwargs.get('email', None)
if email:
return auth.get_user_by_email(app=self.app, email=email)
raise Exception('User id or Email is required')
def userInfor():
email = request.form.get('email')
user = auth.get_user_by_email(email)
return {
'nombre:': user.display_name,
'uid': user.uid,
'email': user.email
}, 200
