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." }