def store(self, request: Request, mail_manager: MailManager, auth: Auth):
"""Register the user with the database.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
user = auth.register({
'name': request.input('name'),
'password': request.input('password'),
'email': request.input('email'),
})
if isinstance(user, MustVerifyEmail):
user.verify_email(mail_manager, request)
# Login the user
if auth.login(request.input('email'), request.input('password')):
# Redirect to the homepage
return request.redirect('/home')
# Login failed. Redirect to the register page.
return request.redirect('/register')
def store(self, request: Request, mail_manager: MailManager, auth: Auth):
"""Register the user with the database.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
user = auth.register({
"name": request.input("name"),
"password": request.input("password"),
"email": request.input("email"),
})
if isinstance(user, MustVerifyEmail):
user.verify_email(mail_manager, request)
# Login the user
if auth.login(request.input("email"), request.input("password")):
# Login successful, Redirect to the homepage
return request.redirect("/home")
# Login failed. Redirect to the register page.
return request.redirect("/register")
def store(self, request: Request):
"""Register the user with the database.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
password = bcrypt_password(request.input('password'))
auth.AUTH['model'].create(
name=request.input('name'),
password=password,
email=request.input('email'),
)
# Login the user
if Auth(request).login(request.input(auth.AUTH['model'].__auth__),
request.input('password')):
# Redirect to the homepage
return request.redirect('/home')
# Login failed. Redirect to the register page.
return request.redirect('/register')
def store(self, request: Request, mail_manager: MailManager):
ok, errors = self.validate_input(request.all())
if not ok:
display = ''
for error in errors:
request.session.flash(
error, '{0} {1} \n\n\n'.format(error.title(),
errors[error][0]))
return request.redirect('/register')
user = auth.AUTH['model'].create(
name=request.input('name'),
password=bcrypt_password(request.input('password')),
email=request.input('email'),
)
if isinstance(user, MustVerifyEmail):
user.verify_email(mail_manager, request)
# Login the user
if Auth(request).login(request.input(auth.AUTH['model'].__auth__),
request.input('password')):
# Redirect to the homepage
return request.redirect('/')
# Login failed. Redirect to the register page.
return request.redirect('/register')
def store(self, request: Request, mail_manager: MailManager):
"""Register the user with the database.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
user = auth.AUTH['model'].create(
name=request.input('name'),
password=bcrypt_password(request.input('password')),
email=request.input('email'),
)
if isinstance(user, MustVerifyEmail):
user.verify_email(mail_manager, request)
# Login the user
if Auth(request).login(request.input(auth.AUTH['model'].__auth__), request.input('password')):
# Redirect to the homepage
return request.redirect('/home')
# Login failed. Redirect to the register page.
return request.redirect('/register')
def show(self, request: Request, view: View):
if not Auth(request).user():
request.redirect('/login')
return view.render('auth/home', {
'app': request.app().make('Application'),
'Auth': Auth(request)
})
def store(self, request: Request, auth: Auth, validate: Validator,
view: View):
user = User.all()
email = User.lists('email')
pw = User.lists('password')
errors = request.validate(validate.required(['email', 'password']),
validate.email('email'))
#checks for errors in login inputs and redirects user back to login page.
if errors:
return request.back().with_errors(errors).with_input()
elif request.input('email') not in email and request.input(
'password') not in pw:
return request.back().with_errors(
{'email': ["Email and password not found. Please register."]})
#check to see if user already had an account which they may have closed/cancelled and need to register for a new account or reactivate account.
if user.where('email',
request.input('email')).where('cancelled', 'Yes'):
# cancelled = True
user_id = User.where('email',
request.input('email')).get().pluck('id')
return request.redirect('/reregister/' + str(user_id[0]))
#logins user if no errors and account has not been closed/cancelled before
if auth.login(request.input('email'), request.input('password')):
return request.redirect('/')
# returns back to login page if email or password are incorrect
return request.back().with_errors(
{'email': ["Email or password is incorrect"]})
def confirm_email(self, request: Request, view: View, auth: Auth,
inertia: InertiaResponse):
sign = Sign()
token = sign.unsign(request.param("id"))
if token is not None:
tokenParts = token.split("::")
if len(tokenParts) > 1:
user = auth.auth_model.find(tokenParts[0])
if user.verified_at is None:
timestamp = datetime.datetime.fromtimestamp(
float(tokenParts[1]))
now = datetime.datetime.now()
timestamp_plus_10 = timestamp + datetime.timedelta(
minutes=10)
if now < timestamp_plus_10:
user.verified_at = datetime.datetime.now()
user.save()
request.session.flash(
'success',
'Your email has successfully been verified.')
return request.redirect("/")
request.session.flash(
'error',
'Something went wrong. We could not verify your email address.')
return request.redirect("/")
def store(self, request: Request, auth: Auth):
"""Login the user.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
auth {masonite.auth.auth} -- The Masonite auth class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
if auth.login(request.input('email'), request.input('password')):
return request.redirect('/home')
return request.redirect('/login')
def show(self, view: View, request: Request):
"""Show the welcome page.
Arguments:
view {masonite.view.View} -- The Masonite view class.
Application {config.application} -- The application config module.
Returns:
masonite.view.View -- The Masonite view class.
"""
if not Auth(request).user():
request.redirect('/login')
else:
request.redirect('/blog')
return view.render('welcome', {'Auth': Auth(request)})
def store(self, request: Request):
"""Login the user.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
if Auth(request).login(request.input('username'),
request.input('password')):
return request.redirect('/home')
return request.redirect('/login')
def send(self, view: View, request: Request, auth: Auth,
validate: Validator, mail: Mail):
email_list = User.lists('email')
email = request.input('email')
encoded_jwt = jwt.encode(
{
'email': email,
'httpMethod': 'GET'
},
'secret',
algorithm='HS256',
).decode('utf-8')
errors = request.validate(validate.required('email'),
validate.email('email'))
if errors:
return request.back().with_errors(errors)
if email not in email_list:
return request.back().with_errors({
'error':
['We can not find your email. Please enter correct email']
})
else:
message = 'Please visit {}/password/reset/get/{} to reset your password'.format(
env('APP_URL', 'http://localhost:8000'), encoded_jwt)
mail.subject('Reset Password Instructions').to(email).send(message)
request.session.flash(
'success',
'An email has been sent. Please follow the instructions in the email to reset your password.'
)
return request.redirect('login'), email
def update(self, request: Request, validate: Validator):
errors = request.validate(
validate.required("password"),
validate.confirmed("password"),
validate.length(
"password",
min=config("auth.password_min_length"),
max=config("auth.password_max_length"),
),
)
if errors:
request.session.flash("error", errors)
return request.back()
user = AUTH["model"].where("remember_token",
request.param("token")).first()
if user:
user.password = bcrypt_password(request.input("password"))
user.remember_token = None
user.save()
if request.user():
auth.sign_out()
request.session.flash(
"success", "Your password has been reset. Login below.")
return request.redirect("/users/sign-in")
def send(self, request: Request, session: Session, mail: Mail,
validate: Validator):
errors = request.validate(validate.required("email"),
validate.email("email"))
if errors:
request.session.flash("error", errors)
return request.back()
email = request.input("email")
user = AUTH["model"].where("email", email).first()
if user:
if not user.remember_token:
user.remember_token = str(uuid.uuid4())
user.save()
link = "{}/users/reset-password/{}".format(
request.environ["HTTP_HOST"], user.remember_token)
mail.subject("{}: Reset Your Password".format(
config("application.name"))).template(
"users/password-reset-email", {
"name": user.name,
"link": link
}).to(user.email).send()
session.flash("success", self.reset_message)
return request.redirect("/")
def store(self, request: Request):
title = request.input('title')
body = request.input('body')
Post.create(title=title, body=body, author_id=1)
return request.redirect('/blog')
def send_verify_email(self, request: Request):
user = request.user()
if isinstance(user, MustVerifyEmail):
request.app().resolve(user.verify_email)
return request.redirect('/home')
def send_verify_email(self, manager: MailManager, request: Request):
user = request.user()
if isinstance(user, MustVerifyEmail):
user.verify_email(manager, request)
return request.redirect('/home')
def send(self, request: Request, session: Session, mail: Mail,
validate: Validator):
errors = request.validate(validate.required('email'),
validate.email('email'))
if errors:
return request.back().with_errors(errors)
email = request.input('email')
user = AUTH['guards']['web']['model'].where('email', email).first()
if user:
if not user.remember_token:
user.remember_token = str(uuid.uuid4())
user.save()
message = 'Please visit {}/password/{}/reset to reset your password'.format(
env('SITE', 'http://localhost:8000'), user.remember_token)
mail.subject('Reset Password Instructions').to(
user.email).send(message)
session.flash(
'success',
'If we found that email in our system then the email has been sent. Please follow the instructions in the email to reset your password.'
)
return request.redirect('/password')
def store(self, request: Request, view: View):
"""
Generate a new token, return to chess/@token/ @show
"""
cur_user = request.user()
friend = request.input('friend', clean=True).strip()
friend_email = User.where('email', friend).limit(1).first()
if not friend_email:
return view.render("invalid",
{"message": 'Username is not exists'})
friend_email = friend_email.email
user_email = cur_user.email
if friend_email == user_email:
return view.render("invalid", {"message": 'You cannot play alone'})
token = token_hex(16)
Table.create(
owner=user_email,
user_id=user_email,
oppo_id=friend_email,
token=token,
completed=False,
last_move_timestamp=current_time(),
next_id=user_email,
move='',
)
return request.redirect("/play/@token", {'token': token})
def once(self, request: Request, validate: Validator, mail: Mail):
email = request.input('email')
encoded_jwt = jwt.encode({'email': email, 'httpMethod': 'GET'}, 'secret', algorithm='HS256', ).decode('utf-8')
errors = request.validate(
validate.required(['service_type', 'name', 'address', 'email', 'cell_phone']))
if errors:
return request.back().with_errors(errors)
OneTimeService.insert({
'service': request.input('service_type'),
'customer_name': request.input('name'),
'address': request.input('address'),
'service_date': request.input('date')[0],
'service_time': request.input('date')[1],
"email": request.input('email'),
'cell_phone': request.input('cell_phone'),
'remember_token': encoded_jwt
})
email = request.input('email')
encoded_jwt = jwt.encode({'email': email, 'httpMethod': 'GET'}, 'secret', algorithm='HS256', ).decode('utf-8')
mail.subject('Pool Appointment Confirmation').to(request.input('email')).template('mail/appt_confirm_guest', {'service': request.input('service_type'),
'service_date': request.input('date')[0], 'service_time': request.input('date')[1], 'token': encoded_jwt }).send()
request.session.flash('success', 'Your appointment has been successfully scheduled! A confirmation email has been sent.')
return request.redirect('/')
def store(self, request: Request, view: View):
#Before saving city in our database, we must ask our API if the city exitsts
API_KEY = '83c2a4b1cd7f54c707c77b0aa0ad102d'
url = 'https://api.openweathermap.org/data/2.5/weather?q={}&units=imperial&appid={}'
city = request.input('name')
city_weather = requests.get(url.format(city, API_KEY)).json()
if city_weather['cod'] == '404':
return request.redirect('/')
else:
City.create(name=request.input("name"))
return request.redirect('/')
def update(self, request: Request):
user = AUTH["model"].where("remember_token",
request.param("token")).first()
if user:
user.password = bcrypt_password(request.input("password"))
user.save()
return request.redirect("/login")
def update(self, request: Request, validate: Validator):
errors = request.validate(
validate.required("password"),
# TODO: only available in masonite latest versions (which are not compatible with Masonite 2.2)
validate.strong(
"password",
length=8,
special=1,
uppercase=1,
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
breach=False,
),
)
if errors:
return request.back().with_errors(errors)
user = (
AUTH["guards"]["web"]["model"]
.where("remember_token", request.param("token"))
.first()
)
if user:
user.password = bcrypt_password(request.input("password"))
user.save()
return request.redirect("/login")
def show(self, view: View, request: Request):
token = request.param('token')
# guest = OneTimeService.where('remember_token', token).get()
# name = guest.pluck('customer_name')[0]
# address = guest.pluck('address')[0]
# email = guest.pluck('email')[0]
# cell_phone = guest.pluck('cell_phone')[0]
# service_id = guest.pluck('id')[0]
if request.user():
user=request.user()
firstname = user.firstname
lastname = user.lastname
address = user.address
service_id = request.param('slug')
token = user.remember_token
return view.render('schedule', {"address": address, "firstname": firstname, "lastname": lastname, "service_id": service_id, 'token': token})
elif not request.user() and not token:
# token = request.param('token')
# return view.render('schedule', {'token': token})
return view.render('schedule')
# return view.render('schedule', {'name':name, 'address':address, 'email': email, 'cell_phone':cell_phone, 'token': token})
elif not request.user():
token = request.param('token')
guest = OneTimeService.where('remember_token', token).get()
name = guest.pluck('customer_name')[0]
address = guest.pluck('address')[0]
email = guest.pluck('email')[0]
cell_phone = guest.pluck('cell_phone')[0]
return view.render('schedule', {'name':name, 'address':address, 'email': email, 'cell_phone':cell_phone, 'token': token})
else:
return request.redirect('/login')
def send(self, request: Request, session: Session, mail: Mail,
validate: Validator):
errors = request.validate(validate.required("email"),
validate.email("email"))
if errors:
return request.back().with_errors(errors)
email = request.input("email")
user = AUTH["guards"]["web"]["model"].where("email", email).first()
if user:
if not user.remember_token:
user.remember_token = str(uuid.uuid4())
user.save()
message = "Please visit {}/password/{}/reset to reset your password".format(
env("SITE", "http://localhost:8000"), user.remember_token)
mail.subject("Reset Password Instructions").to(
user.email).send(message)
session.flash(
"success",
"If we found that email in our system then the email has been sent. Please follow the instructions in the email to reset your password.",
)
return request.redirect("/password")
def show(self, request: Request, inertia: InertiaResponse):
if request.user():
request.session.flash("warning", "You are already logged in.")
return request.redirect("/")
return inertia.render("UserSignUp")
def store(self, request: Request):
"""Login the user.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
Returns:
masonite.request.Request -- The Masonite request class.
"""
if Auth(request).login(request.input('email'),
request.input('password')):
return request.redirect('/')
request.session.flash('login_error',
'These credentials do not match our records.')
return request.redirect('/login')
def update(self, request: Request):
user = AUTH['model'].where('remember_token',
request.param('token')).first()
if user:
user.password = bcrypt_password(request.input('password'))
user.save()
return request.redirect('/login')
def update(self, view: View, request: Request, validate: Validator, mail: Mail):
schedule_date_info = request.input('date')
customer = request.user()
#checking that all required fields are entered and no errors are found.
errors = request.validate(
validate.required(['service_type', 'name', 'address']))
if errors:
return request.back().with_errors(errors)
if not schedule_date_info[0] or not schedule_date_info[1]:
request.session.flash('success', "The service date and service time is required.")
return request.back()
update_schedule = Schedule.where('id', '=', request.param('slug')).update(service=request.input('service_type'),
service_date=schedule_date_info[0], service_time=schedule_date_info[1])
#need to changed this variable to current new updated info to send in email confirmation.
customer_schedule = Schedule.get().last()
#sends email with pool appointment schedule details
mail.subject('Pool Appointment Update Confirmation').to(customer.email).template('mail/appt_confirm', {'service_id': request.param('slug'), 'service': customer_schedule.service,
'service_date':customer_schedule.service_date, 'service_time':customer_schedule.service_time}).send()
request.session.flash('success', 'Your appointment has been updated! A confirmation email has been sent.')
return request.redirect('/')
def send_verify_email(self, manager: MailManager, request: Request):
user = request.user()
if isinstance(user, MustVerifyEmail):
user.verify_email(manager, request)
request.session.flash("success", "A verification email has been sent.")
return request.redirect("/")
