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 show(self, view: View, request: Request): if request.input('search'): users = self.__auth__.all().filter(lambda user: self.search(request.input('search'), user)) else: users = self.__auth__.all() return view.render('{0}/management/management'.format(self.template_prefix), {'users': users})
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): email = request.input('email') password = request.input('password') user = AUTH['model'].where('email', email).first() login = checkpw(bytes(password, 'utf-8'), bytes(user.password, 'utf-8')) if login: hash = LoginToken().login(int(user.id), int(user.permission)) return { 'login': True, 'token': hash, 'id': user.id, 'name': user.name, 'permission': user.permission } # Delete existing token # LoginToken.where('admin_user_id', user.id).delete() # hash = secrets.token_urlsafe() # login_token = LoginToken() # login_token.admin_user_id = user.id # login_token.token = hash # login_token.save() # return {'login': True, 'token': hash, 'id': user.id, 'name': user.name} else: return {'login': False}
def index(self, view: View, request: Request): path = config('browserlog.BROWSERLOG_STORAGE_PATH') log_files = listdir(path) logs = [] q = int(request.input('q', '0')) action = request.input('action') if action == 'clean': open('{0}/{1}'.format(path, log_files[q]), 'w').close() if action == 'download': return Download('{0}/{1}'.format(path, log_files[q]), name=log_files[q].split('.')[0], force=True) try: log_files[q] except IndexError: q = 0 for line in open('{0}/{1}'.format(path, log_files[q]), 'r'): if parse_log(line): logs.append(parse_log(line)) return view.render('browserlog/index.html', { 'log_files': log_files, 'logs': logs, 'q': q })
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 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 jwt(self, request: Request, auth: Auth): if not request.input('username') or not request.input('password'): request.status(401) return {'error': 'missing username or password'} user = auth.once().login( request.input('username'), request.input('password'), ) if user: user.__hidden__ = ['password'] payload = { 'issued': str(pendulum.now()), 'expires': str(pendulum.now().add(minutes=5)), 'refresh': str(pendulum.now().add(days=14)), 'scopes': request.input('scopes'), 'user': user.serialize() } return { 'token': bytes(jwt.encode(payload, KEY, algorithm='HS256')).decode('utf-8'), 'expires_at': payload['expires'], 'refresh_expires_at': payload['refresh'], } return {'error': 'invalid authentication credentials'}
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 sign_in(self, request: Request, response: Response, auth: Auth, validate: Validator): errors = request.validate(validate.required("email"), validate.required("password")) if errors: return errors user_auth_res = auth.login(request.input("email"), request.input("password")) if user_auth_res is False: return response.json({"error": "Check your credentials"}) msg = { "id": user_auth_res.id, "email": user_auth_res.email, "name": user_auth_res.name, "govId": user_auth_res.gov_id, "type": user_auth_res.type, } enc = utils.encode_message(msg) if enc != False: return response.json({"access_token": enc.decode("utf-8")}) return response.json( {"error": "You cannot access this system at the time"})
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): # 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 login(self, request: Request, auth: Auth): email = request.input('user.email') password = request.input('user.password') if auth.once().login(email, password): user = User.where('email', email).first() user.generate_token() return {'user': user.serialize()} request.status(400) return {'error': 'username or password incorrect'}
def store(self, request: Request): post = Post.find(request.param('id')) post.title = request.input('title') post.body = request.input('body') post.save() return 'post updated'
def store(self, view: View, request: Request): # сохранение обновленого содержимого поста в бд post = Post.find(request.param('id')) post.title = request.input('title') post.body = request.input('body') post.save() return 'post updated'
def store(self, request: Request, validator: Validator): errors = request.validate(validator.required(['name', 'description'])) if errors: return {'errors': errors} Competition.create(name=request.input('name'), description=request.input('description')) return {'status': 'success'}
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 add(self,upload: Upload, view: View, request: Request): team_member = request.input('full_name') id = Member.insert_get_id({ 'full_name': team_member, 'position': request.input('position'), 'image_url': upload.driver('disk').store(request.input('file_upload')), 'company': request.input('company') }) return view.render('form_success', compact(team_member))
def update(self, request: Request): post = Post.find(request.params.get('id')) post.category_id = request.input('category_id') post.content = request.input('content') post.title = request.input('title') post.slug = sluglify(request.input('title')) post.date = datetime.now() post.save() return 'Post updated !'
def test_get_json_input(self): json_wsgi = wsgi_request json_wsgi['REQUEST_METHOD'] = 'POST' json_wsgi['CONTENT_TYPE'] = 'application/json' json_wsgi['QUERY_STRING'] = '' json_wsgi['wsgi.input'] = MockWsgiInput() Route(json_wsgi) request_obj = Request(json_wsgi) assert isinstance(request_obj.request_variables, dict) assert request_obj.input('id') == 1 assert request_obj.input('test') == 'testing'
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 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 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 store(self, request: Request, response: Response, validate: Validator): errors = request.validate( validate.required("symptoms"), validate.required("diagnosis"), validate.required("treatment_plan"), validate.required("seen_by"), ) if errors: return errors patient_id = request.param("patient_id") patient_record = { "author": f"{self.user.gov_id}@afyamkononi", "timestamp": calendar.timegm(time.gmtime()), "symptoms": request.input("symptoms"), "diagnosis": request.input("diagnosis"), "treatment_plan": request.input("treatment_plan"), "seen_by": request.input("seen_by"), } patient_account = self.ibc.get_account_details( request.param("patient_id")) if patient_account.detail == "": return response.json({"error": "No such account"}) unpacked_data = json.loads(patient_account.detail) patient_history = utils.filter_medical_data(unpacked_data) history_update = [] if patient_history == []: history_update.append(patient_record) else: history_update += patient_history history_update.append(patient_record) history_update = utils.remove_duplicates(history_update) blockchain_status = self.ibc.set_patient_record( User.where("gov_id", patient_id).first(), history_update) print(blockchain_status) iroha_message = iroha_messages.update_medical_history_failed( blockchain_status) if iroha_message is not None: return response.json(iroha_message) return response.json({"success": "Medical data added successfully"})
def register(self, request: Request, auth: Auth, validate: Validator): """ register a new administrator and also checks that form is filled out properly without errors and checks to see if email, passwords, and usernames alread exits""" email = Administrator.lists('admin_email') user_name = Administrator.lists('admin_username') pw = Administrator.lists('password') #check to see if emails or usernames already exist accounts = [email, user_name] inputs = [request.input('admin_email'), request.input('admin_username')] for input in inputs: for account in accounts: if inputs[0] in accounts[0] and inputs[1] in accounts[1]: return request.back().with_errors({'error': ['{} and {} already exists'.format(inputs[0], inputs[1])]}) elif input in account: return request.back().with_errors({'error': ['{} already exists'.format(input)]}) #checking to see if password already exists for pw in pw: if bcrypt.checkpw(bytes(request.input('admin_password'), 'utf-8'), bytes(pw, 'utf-8')): return request.back().with_errors({'error': ['Password already exists. Please create a new password.']}) #checking for user entry errors when registering as an Administrator errors = request.validate( validate.required(['admin_name', 'admin_cell_phone', 'admin_address', 'admin_email', 'admin_username', 'admin_password']), validate.email('admin_email'), validate.strong('admin_password', length=8, special=1, uppercase=1) ) if errors: return request.back().with_errors(errors).with_input() #when everything above checks out ok, then go ahead and insert data in Administrator table else: encoded_jwt = jwt.encode({'email': request.input('admin_email')},os.getenv('KEY') ,algorithm='HS256') encrypted_password = password(request.input('admin_password')) Administrator.insert(admin_name=request.input('admin_name'), admin_cell_phone=request.input('admin_cell_phone'), admin_address=request.input('admin_address'), admin_email=request.input('admin_email'), admin_username=request.input('admin_username'), password=encrypted_password, remember_token=encoded_jwt) return request.redirect('/admin')
def store( self, request: Request, mail_manager: MailManager, auth: Auth, validate: Validator, ): """Register the user with the database. Arguments: request {masonite.request.Request} -- The Masonite request class. Returns: masonite.request.Request -- The Masonite request class. """ errors = request.validate( validate.required(["name", "email", "password"]), validate.email("email"), 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).with_input() 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.back().with_input()
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, 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})