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})
