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 show(self, view: View, request: Request):
if request.user():
return view.render('account_cancel')
elif not request.user():
today = date.today()
token = request.param('token')
decoded_token = jwt.decode(token, 'secret', algorithm='HS256')
guest = OneTimeService.where(
'email', decoded_token['email']).update(cancelled_on=today)
return view.render('mail/cancel_guest', {'token': token})
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 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 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_verify_email(self, request: Request):
user = request.user()
if isinstance(user, MustVerifyEmail):
request.app().resolve(user.verify_email)
return request.redirect('/home')
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 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 current_user(self, request: Request):
token = jwt.decode(request.header('HTTP_AUTHORIZATION').replace(
'Token ', ''), KEY, algorithms=['HS256'])
if pendulum.parse(token['expires']).is_past():
request.status(401)
return {'error': 'Your token has expired'}
return {'user': request.user().serialize()}
def store(self, request: Request):
# New store Method
Post.create(title=request.input('title'),
image='no img',
body=request.input('body'),
author_id=request.user().id)
return 'post created'
def show(self, view: View, request: Request):
user = request.user()
customer_schedules = Schedule.where('schedule_id', user.id).get()
address = user.address
return view.render('pool_appointments', {
'customer_schedules': customer_schedules,
'address': address
})
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("/")
def currunt_user(self, request: Request):
token = jwt.decode(request.header('HTTP_AUTHORIZATION').replace(
'Token ', ''),
KEY,
algorithms=['HS256'])
if pendulum.parse(token['expires']).is_past():
raise ExpiredToken
return {'user': request.user().serialize()}
def __init__(self, request: Request):
"""PatientRecordsController Initializer
Arguments:
request {masonite.request.Request} -- The Masonite Request class.
"""
self.request = request
self.user = request.user()
self.ibc = IrohaBlockchain(self.user)
def show(self, view: View, request: Request):
"""
Show all users so player can pick one user to play with
"""
users = User.all()
table = Table.all()
if request.user():
cur_user = request.user().email
return view.render(
"game", {
'users': users,
'name': cur_user,
'table': table,
"cuser_id": cur_user
})
else:
return view.render("invalid", {"message": 'Please log in'})
def verify_show(self, request: Request, view: View):
if not request.user():
request.session.flash(
"warning",
"You must be logged in to verify your email address.")
return request.redirect("/users/sign-in")
return view.render("users/email-verification")
def store(self, request: Request):
Entry.create(
note=request.input("note"),
rating=request.input("rating"),
author_id=request.user().id,
entry_for_date=datetime.today().strftime("%Y-%m-%d"),
)
request.session.flash("success", "Entry Added Successfully!")
return request.redirect("/home")
def show(self, view: View, request: Request):
# Show move in the game
token = request.param('token')
table = Table.where('token', token).limit(1).first()
if not request.user():
return view.render("invalid", {"message": 'Please login first'})
# Non exist token
if not table:
return view.render("invalid",
{"message": 'Your Token is not existed'})
# Exist token, but no permission
if request.user().email not in (table.user_id, table.oppo_id):
return view.render("invalid",
{"message": 'You cannot view this game'})
if table.winner:
return view.render("invalid", {"message": 'Game over'})
# Check time out
if table.completed:
return view.render("invalid", {"message": 'Time out'})
if current_time() - table.last_move_timestamp > 300:
table.completed = True
table.save()
return view.render("invalid", {"message": 'Time out'})
# If everything okay, print out current move of this game
timeleft = 300 - (current_time() - table.last_move_timestamp)
your_turn = table.next_id == request.user().email
return view.render('chess', {
'table': table,
'your_turn': your_turn,
'timeleft': timeleft
})
def update(self, request: Request, validate: Validator, auth: Auth,
view: View):
user = User.all()
customer = request.user()
email = User.lists('email')
user_name = User.lists('username')
#Checks to see if updated email or username already exists
if request.input('email') != customer.email:
if request.input('email') in email:
return request.back().with_errors({
'error':
['{} already exists'.format(request.input('email'))]
})
elif request.input('username') != customer.username:
if request.input('username') in user_name:
return request.back().with_errors({
'error':
['{} already exists'.format(request.input('username'))]
})
#Inputs to update customer information
user.where(
'id',
customer.id).first().update(firstname=request.input('firstname'))
user.where(
'id',
customer.id).first().update(lastname=request.input('lastname'))
user.where(
'id', customer.id).first().update(address=request.input('address'))
user.where(
'id',
customer.id).first().update(cell_phone=request.input('cell_phone'))
user.where('id',
customer.id).first().update(email=request.input('email'))
user.where(
'id',
customer.id).first().update(username=request.input('username'))
#Checks that all information is filled out properly
errors = request.validate(
validate.required(
['firstname', 'lastname', 'address', 'email', 'username']),
validate.email('email'))
if errors:
return request.back().with_errors(errors).with_input()
else:
request.session.flash(
'success', 'Your account has been successfully updated.')
return request.redirect('account')
def update(self, view: View, request: Request, auth: Auth,
validate: Validator):
user = User.all()
pws = User.lists('password')
customer = request.user()
pw = customer.password
if bcrypt.checkpw(bytes(request.input('password'), 'utf-8'),
bytes(pw, 'utf-8')) == False:
return request.back().with_errors(
{'error': ['Please enter correct old password']})
new_password = request.input('new_password')
confirm_password = request.input('confirm_password')
for pws in pws:
if bcrypt.checkpw(bytes(request.input('new_password'), 'utf-8'),
bytes(pws, 'utf-8')):
return request.back().with_errors({
'error': [
'Password already exists. Please create a new password.'
]
})
errors = request.validate(
validate.required(['password', 'new_password',
'confirm_password']),
validate.strong('new_password',
length=8,
special=1,
uppercase=1,
breach=False)
# breach=True checks if the password has been breached before.
# Requires 'pip install pwnedapi'
)
if errors:
return request.back().with_errors(errors).with_input()
elif new_password != confirm_password:
return request.back().with_errors({
'error':
['New password and confirm new password do not match!']
})
else:
user.where(
'id',
customer.id).first().update(password=password(new_password))
request.session.flash(
'success', 'Your password has been successfully updated.')
return request.redirect('account')
def show(self, request: Request, view: View, auth: Auth):
"""Show the login page.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
view {masonite.view.View} -- The Masonite view class.
auth {masonite.auth.auth} -- The Masonite auth class.
Returns:
masonite.view.View -- Returns the Masonite view class.
"""
if request.user():
return request.redirect('/home')
return view.render('auth/login', {'app': request.app().make('Application'), 'Auth': auth})
def show(self, request: Request, view: View):
"""Show the login page.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
view {masonite.view.View} -- The Masonite view class.
Returns:
masonite.view.View -- Returns the Masonite view class.
"""
if request.user():
return request.redirect("/home")
return view.render("auth/login")
def show(self, request: Request):
if request.user() and request.user().is_admin:
return view('/dashboard/templates/dashboard/index')
if request.user():
request.session.flash('danger', 'You are not an admin')
return request.redirect('/dashboard/login')
# def single(self):
# model = request().app().make('DashboardModels')[request().param('model')]
# if model.__table__:
# table_name = model.__table__
# else:
# table_name = model.__name__ + 's'
# conn = DB.get_schema_manager().list_table_columns(table_name.lower())
# model = model.find(request().param('id'))
# return view('/dashboard/templates/single', {'model': model, 'getattr': getattr, 'model_schema': conn.items()})
# def show_all(self):
# model = request().app().make('DashboardModels')[request().param('model')]
# models = model.all()
# return view('/dashboard/templates/show', {'modelclass': model, 'models': models})
# def update(self):
# model = request().app().make('DashboardModels')[request().param('model')]()
# model = model.find(request().param('id'))
# for key in request().all():
# if hasattr(model, key):
# setattr(model, key, request().input(key))
# model.save()
# return request().redirect('/dashboard/{}/{}'.format(model.__class__.__name__.lower(), request().param('id'))) \
# .session.flash('message', 'Updated Successfully')
def contact(self, request: Request, auth: Auth, validate: Validator, mail: Mail):
user_email = request.user().email
message = request.input('contact')
message_subject = request.input('subject')
errors = request.validate(
validate.required(['subject', 'contact']),
)
if errors:
return request.back().with_errors(errors)
else:
mail.send_from(user_email).subject(message_subject).to('*****@*****.**').send(message)
request.session.flash('success', 'Your message has been successfully sent!')
return request.redirect('/')
def create(self, request: Request):
category_id = request.input('category_id')
content = request.input('content')
title = request.input('title')
slug = sluglify(title)
date = datetime.now()
Post.create(content=content,
title=title,
slug=slug,
date=date,
category_id=category_id,
author_id=request.user().id)
return 'Post created !'
def create(self, request: Request, validator: Validator,
validate: Validator):
comment_data = request.input('comment')
errors = validator.validate(
comment_data,
validate.required(['body']),
)
if errors:
request.status(422)
return {'errors': errors}
article = Article.where('slug', request.param('slug')).first()
comment = Comment(body=comment_data['body'],
author_id=request.user().id)
article.comments().save(comment)
request.status(201)
return {'comment': comment.payload()}
def show(self, request: Request, view: View, auth: Auth):
"""Show the login page.
Arguments:
request {masonite.request.Request} -- The Masonite request class.
view {masonite.view.View} -- The Masonite view class.
auth {masonite.auth.auth} -- The Masonite auth class.
Returns:
masonite.view.View -- Returns the Masonite view class.
"""
if request.user():
return request.redirect("/home")
return view.render("auth/login", {
"app": request.app().make("Application"),
"Auth": auth
})
def show(self, view: View, request: Request):
user = request.user()
firstname = user.firstname
lastname = user.lastname
address = user.address
cell = user.cell_phone
email = user.email
username = user.username
password = user.password
return view.render(
'account_update', {
'firstname': firstname,
'lastname': lastname,
'address': address,
'cell_phone': cell,
'email': email,
'username': username
})
def cancel(sef, request: Request, auth: Auth, validate: Validator,
mail: Mail):
user = User.all()
customer = request.user()
pw = customer.password
reason = request.input('radio')
confirm_password = request.input('password')
#checking that all required fields are entered and no errors are found.
errors = request.validate(
validate.required(
['radio', 'password'],
messages={'radio': "Please choose a reason for cancelling."}))
if errors:
return request.back().with_errors(errors)
elif not bcrypt.checkpw(bytes(confirm_password, 'utf-8'),
bytes(pw, 'utf-8')):
return request.back().with_errors(
{'error': ["Are you sure that's the right password?"]})
user_id = user.where('id', customer.id).first()
# User.where('id', customer.id).where_null('cancelled').update(cancelled='Yes')
User.where('id', customer.id).update(cancelled="Yes")
CancelledAccount.insert({
'user_id': user_id.id,
'cancel_reason': request.input('radio'),
'suggestions': request.input('suggestion')
})
request.session.flash(
'success',
'Your account has been successfully cancelled. Thank you for your business.'
)
mail.send_from('*****@*****.**').subject(
'Cancellation Confirmation').to(customer.email).template(
'mail/cancel_member', {
'title': 'Kennedy Pools & Supplies'
}).send()
auth.logout()
return request.redirect('/')
def book_show(self, request: Request):
"""Logic to create data from a given model
"""
show_id = request.param('show')
show = MovieShow.find(show_id)
if not show:
raise ValueError('Invalid request')
seats = request.input('seats')
user = request.user()
if seats < 1:
raise ValueError(
'You must select at least one seat for this booking')
while seats > 0:
MovieBooking.create({"user_id": user.id, "show_id": show.id})
return {
"message":
"Seat has been confirmed. You will receive an email shortly with details."
}
