def get_file(self, ref=False):
list_git_files = self.get_posts_json(ref)
if not list_git_files:
list_git_files = False
if ref:
get_file('static/%s_%s_branch.txt' % (self.git_name.lower(), self.git_repository_blog.lower()),
list_git_files)
elif not ref:
get_file('static/%s_%s.txt' % (self.git_name.lower(), self.git_repository_blog.lower()),
list_git_files)
return False
if ref:
get_file('static/%s_%s_branch.txt' % (self.git_name.lower(), self.git_repository_blog.lower()),
list_git_files)
elif not ref:
get_file('static/%s_%s.txt' % (self.git_name.lower(), self.git_repository_blog.lower()),
list_git_files)
user_s = Users(self.git_name, self.git_repository_blog)
session_git = user_s.open_base()
users = session_git.query(Users)
new_user = True
for user in users:
if user.user_name == self.git_name.lower() and user.user_repo_name == self.git_repository_blog.lower():
session_git.close()
new_user = False
if new_user:
new_user = Users(user_name=self.git_name.lower(), user_repo_name=self.git_repository_blog.lower())
session_git.add(new_user)
session_git.commit()
session_git.close()
posts = sorted(list_git_files, key=lambda d: d['date'], reverse=True)
if not posts[0]['date']:
return [{'date': False}]
return posts
def help_take_data_git(git_access, git_name, git_repository_blog):
create_repo = git_access.create_repo(git_repository_blog)
if create_repo.status_code == 201:
git_access.get_file()
users_list = Users(git_name, git_repository_blog)
users_list.new_user()
return jsonify({'message': 'new repo created'})
elif create_repo.status_code == 422:
users_list = Users(git_name, git_repository_blog)
users_list.new_user()
return jsonify({'message': 'repo is empty'})
else:
return abort(404)
def newTeam():
if request.method == 'POST':
teamName = request.form['teamName']
password = request.form['password']
teamDescription = request.form['description']
if 'file' not in request.files:
#ADD CHANGES TO DATABASES
user = Users(username=teamName, password=password, userType='team')
team = Teams(teamName=teamName,
teamDescription=teamDescription,
totalPoints=0)
db.session.add(user)
db.session.add(team)
db.session.commit()
else:
image_file = request.files['file']
# if image filename is empty string
if image_file.filename == '':
#ADD CHANGES TO DATABASES
user = Users(username=teamName,
password=password,
userType='team')
team = Teams(teamName=teamName,
teamDescription=teamDescription,
totalPoints=0)
db.session.add(user)
db.session.add(team)
db.session.commit()
# if image is allowed
elif image_file and allowed_file(image_file.filename,
ALLOWED_EXTENSIONS):
filename = secure_filename(image_file.filename)
image_file.save(
os.path.join(app.config['UPLOAD_FOLDER'], filename))
user = Users(username=teamName,
password=password,
userType='team')
team = Teams(teamName=teamName,
teamDescription=teamDescription,
teamPhoto=str(filename),
totalPoints=0)
db.session.add(user)
db.session.add(team)
db.session.commit()
return render_template('teamForm.html')
def create(cls, session: Session, user: UserBaseCreate) -> Users:
db_user = Users(**user.dict())
db_user.password = Security.get_pwd_hash(user.password)
session.add(db_user)
session.commit()
session.refresh(db_user)
return db_user
def get_all_users():
# Open a connection to the database
with sqlite3.connect("rare.db") as conn:
# Just use these. It's a Black Box.
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
# Write the SQL query to get the information you want
db_cursor.execute("""
SELECT
u.id,
u.email,
u.name,
u.password
FROM users u
""")
# Initialize an empty list to hold all user representations
users = []
# Convert rows of data into a Python list
dataset = db_cursor.fetchall()
# Iterate list of data returned from database
for row in dataset:
user = Users(row['id'], row['email'], row['name'], row['password'])
users.append(user.__dict__)
# Use `json` package to properly serialize list as JSON
return json.dumps(users)
def check_if_valid(post_body):
# {'password': '******', 'email': '*****@*****.**'}
password = post_body['password']
email = post_body['email']
with sqlite3.connect("rare.db") as conn:
# Just use these. It's a Black Box.
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
# Write the SQL query to get the information you want
db_cursor.execute("""
SELECT
u.id,
u.email,
u.name,
u.password
FROM users u
WHERE u.email = ? AND u.password = ?
""", (email, password, ))
# Initialize an empty list to hold all user representations
# Convert rows of data into a Python list
data = db_cursor.fetchone()
user = Users(data['id'], data['email'], data['name'], data['password'])
# Iterate list of data returned from database
response_object = {'valid': True, 'id': user.id}
return json.dumps(response_object)
def user_login():
try:
user_data = request.get_json()
username = user_data['username']
password = user_data['password']
except Exception as error:
return jsonify({
"Error": "Invalid User Input",
"message": "missing either username or password",
"status": 400
}), 400
user = Users(['', username, password, ''])
found_user = user.query_login()
if found_user is not None:
print(password)
print(found_user.password)
if found_user.password == password:
token = found_user.generate_auth_token()
return jsonify({
'user': username,
'token': token['sub'],
'message': 'login was successful'
}), 200
else:
return jsonify({'Error': 'Incorrect Password'}), 403
return jsonify({'Error': 'Username not found'}), 403
def user_register():
try:
user_data = request.get_json()
name = user_data['name']
username = user_data['username']
password = hash_password(user_data['password'])
email = user_data['email']
except Exception as error:
return make_response(
jsonify({
"error": "invalid user data input",
"message": "missing either name, username, email or password",
"status": 400
}), 400)
new_user = Users([name, username, password, email])
if not new_user.is_existing_user():
new_user.create_new_user()
return make_response(
jsonify({
"status": 201,
"message": "user created successfully"
}), 201)
return make_response(
jsonify({
"status": 403,
"message": "username already exists"
}), 403)
def register():
"""
User register view.
:return: HTTP Response
"""
if request.method == 'GET':
return render_template('register-page.html')
else:
required_inputs = [
'username', 'email', 'password1', 'password2',
'terms_and_conditions'
]
form_inputs = ['bio', 'country', 'city', 'school']
for inp in required_inputs:
if inp not in request.form:
return redirect(url_for('core.home'))
if is_mail(request.form['email']) is None or \
request.form['password1'] != request.form['password2'] or \
not password_validation(request.form['password1']):
return redirect(url_for('core.home'))
user = Users(username=request.form['username'],
email=request.form['email'])
for inp in form_inputs:
if inp in request.form:
user.__setattr__(inp, request.form[inp])
user.save()
user.set_password(request.form['password1'])
login_user(user)
return redirect(url_for('core.home'))
def connect_with_user():
'''Make a connection with a 'normal' user'''
error = None
current_user_id = session.get('logged_in_user')
if request.method == 'POST':
# fetch values and check they are actually provided
if 'key' in request.form:
key_value = request.form['key']
useri = Users(current_user_id)
key_user_id = useri.validate_key(key_value)
# valid key
if key_user_id:
# cannot connect to ourselves and make a connection that has already been made ;)
if not key_user_id == current_user_id and not useri.is_connection(user_id=key_user_id):
# create connections from us to them and back
useri.add_connection(key_user_id)
flash('Connection made')
else: error = 'I can haz myself impossible'
else: error = 'Invalid key'
else: error = 'You need to provide a key'
return render_template('admin_connect_with_user.html', **locals())
def schedule():
data = request.get_json()
token = data.get("token")
user_info = Users.authenticate(token)
user = Users(user_info[0][1],
user_info[0][2],
user_info[0][4],
twitch_id=user_info[0][3])
# get schedule info from react the "data" coming in will need to have a lot of info
# i.e. date, a time slots array, a performers array, user_id will come from the auth here in the route,
# and the unique sked_id generated here:
sk_id = sked_id_gen()
# print(sk_id)
time_slots = data.get("timeSlots")
# print(time_slots)
performers = data.get("performers")
# print(performers)
print(user_info[0][3], data.get("date"), time_slots[0], performers[0])
for i in range(len(time_slots)):
sked = Schedule(user_info[0][3],
data.get("date"),
time_slots[i],
performers[i],
sked_id=sk_id)
sked._insert()
return jsonify({"create": "successful", "sk_id": sk_id})
def logout():
data = request.get_json()
token = data.get("token")
user_info = Users.authenticate(token)
user = Users(user_info[0][1], user_info[0][2], user_info[0][4])
user.logout()
return jsonify({"logout": "successful"})
def create_user(self):
username = input("Please enter a username: "******"Enter your password: ")
password_hash = hashlib.sha256(str_password.encode()).hexdigest()
user = Users(username)
user.save_user_to_mongo(password_hash)
self.user = username
def post(self) -> Response:
body = request.get_json()
try:
key = uuid.uuid4().int
data = {
'staffID': str(key)[0:6],
'username': body['username'],
'password': body['password'],
'name': body['name'],
'role': body['role'],
'department': body['department'],
'create_at': str(datetime.utcnow()),
'update_at': str(datetime.utcnow()),
}
user = Users(**data)
user.save()
response = jsonify({
"data": data,
"message": "success",
"status": 200
})
response.status_code = 201
return response
except Exception as e:
response = jsonify({
"data": None,
"message": "error",
"status": 204
})
response.status_code = 204
return response
def update_user():
response.content_type = 'application/json'
user = request.json
new_user = Users(**user)
session.add(new_user)
session.commit()
return json.dumps(new_user.to_dict())
def register() -> Response:
form = RegistrationForm()
if form.validate_on_submit():
username = form.data['username']
password = form.data['password']
mail = form.data['mail']
hashed_pswd = pbkdf2_sha256.hash(password)
user = Users(username=username,
mail=mail,
password=hashed_pswd,
confirmed=False)
db.session.add(user)
db.session.commit()
token = SendingMails(app, mail).generate_confirmation_token(user.mail)
confirm_url = url_for('confirm_email', token=token, _external=True)
html = render_template('users/activate.html', confirm_url=confirm_url)
subject = "Please confirm your email"
SendingMails(app, mail).send_email(user.mail, subject, html)
flash('A confirmation email has been sent via email. :)', 'success')
return redirect(url_for('unconfirmed'))
return render_template('users/register.html', form=form)
def register():
userId = "522422199412263654"
cardId = "522422199412263654"
username = "******"
password = "******"
group = "技术部"
phone = "18212707348"
type = '1'
regTime = datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S')
pd = generate_password_hash(password)
try:
data = Users(userId=userId,
cardId=cardId,
username=username,
passWord=pd,
group=group,
phone=phone,
type=type,
regTime=regTime)
db.session.add(data)
db.session.commit()
except Exception as e:
print(e)
print('添加用户错误')
return jsonify({"message": "ok"})
def post() -> Response:
"""
POST response method for creating user.
:return: JSON object
"""
data = request.get_json()
usercart = Cart().save()
output = {'id': str(usercart.id)}
y = {"cartId": str(usercart.id)}
print('usercart')
print(usercart.id)
print(usercart.products)
print('data')
print(data)
data.update(y)
print('data')
print(data)
post_user = Users(**data)
try:
post_user.save()
except NotUniqueError as exc:
return {'message': "Email Id already exits!!"}, 400
output = {'id': str(post_user.id)}
return jsonify({'result': output})
def create_user(self):
"""
회원가입한 유저 정보 DB에 저장
:return: Boolean
"""
name = self._body.get('name')
nickname = self._body.get('nick_name')
password = self._body.get('password')
phone = self._body.get('phone')
email = self._body.get('email')
gender = self._body.get('gender')
password = self.encrypt_password(password=password)
session = db.session()
try:
user = Users(name=name,
nickname=nickname,
password=password,
phone=phone,
email=email,
gender=gender)
session.add(user)
except Exception as e:
print(f'err : {e}')
session.rollback()
return False
else:
session.commit()
session.close()
return True
def export(direction=None, user=None, date=None):
'''Export loan entries'''
current_user_id = session.get('logged_in_user')
our_loans = Loans(current_user_id)
our_users = Users(current_user_id)
# fetch loans
loans = our_loans.get_loans()
# fetch users from connections from us
users = our_users.get_connections()
# provided user?
if user:
# valid slug?
user_id = our_users.is_connection(slug=user)
if user_id: loans = our_loans.get_loans(user_id=user_id)
# provided a date range?
date_range = translate_date_range(date)
if date_range:
loans = our_loans.get_loans(date_from=date_range['low'], date_to=date_range['high'])
# date ranges for the template
date_ranges = get_date_ranges()
# provided a direction?
if direction: loans = our_loans.get_loans(direction=direction)
response = make_response(render_template('admin_export_loans.html', **locals()))
response.headers['Content-type'] = 'text/csv'
response.headers['Content-disposition'] = 'attachment;filename=' + 'loans-' + str(today_date()) + '.csv'
return response
def generate_test_users(filepath: str = 'resources/user_data.csv',
delimiter: str = '\t'):
"""
Converts data in csv file to documents in user collection.
Uses @mongo wrapper to connect via mongoengine during execution.
Randomly generates fav_meals list and access__admin parameters.
:param filepath:
:param delimiter:
:return:
"""
with open(filepath, 'r') as file:
data = csv.DictReader(file, delimiter=delimiter)
for datum in data:
try:
user = Users(**datum, __auto_convert=True)
# generate random admin access, password, and favorite meals
user.access.admin = (randint(0, 1) == 1)
user.fav_meals = get_random(Meals, randint(1, 5))
user.password = user.name + str(randint(0, 9))
user.save()
print(
f"Added: {user.name} | {user.email} | {user.password} | Admin-{user.access.admin is True} => {user.id}"
)
except NotUniqueError:
print(f'Invalid Entry: {user.email} is already taken.')
except ValidationError:
print(f'Validation Error: {user}')
def index(direction=None, user=None, date=None, page=1, items_per_page=10):
'''List loans user has with other users'''
current_user_id = session.get('logged_in_user')
our_loans = Loans(current_user_id)
our_users = Users(current_user_id)
# fetch loans
loans = our_loans.get_loans()
# fetch users from connections from us
users = our_users.get_connections()
# provided user?
if user:
# valid slug?
user_id = our_users.is_connection(slug=user)
if user_id: loans = our_loans.get_loans(user_id=user_id)
# provided a date range?
date_range = translate_date_range(date)
if date_range:
loans = our_loans.get_loans(date_from=date_range['low'], date_to=date_range['high'])
# date ranges for the template
date_ranges = get_date_ranges()
# provided a direction?
if direction: loans = our_loans.get_loans(direction=direction)
# build a paginator
paginator = Pagination(loans, page, items_per_page, loans.count(),
loans.offset((page - 1) * items_per_page).limit(items_per_page))
return render_template('admin_show_loans.html', **locals())
def post():
data = request.get_json()
post_user = Users(**data)
post_user.save()
output = {'id': str(post_user.id)}
return jsonify({'result': output})
def give():
'''Give a loan or pay someone back'''
current_user_id = session.get('logged_in_user')
our_accounts = Accounts(current_user_id)
if request.method == 'POST':
dict = __validate_give_loan_form()
for key in dict.keys(): exec(key + " = dict['" + key + "']")
# 'heavier' checks
if not error:
# valid amount?
if is_float(amount):
# valid date?
if is_date(date):
# valid account?
if our_accounts.is_account(account_id=deduct_from_account):
# add our loans entry
our_loans = Loans(current_user_id)
our_loan_id = our_loans.add_loan(other_user_id=to_user, date=date, account_id=deduct_from_account,
description=description, amount=-float(amount))
# add their loans entry
their_loans = Loans(to_user)
their_loan_id = their_loans.add_loan(other_user_id=current_user_id, date=date,
account_id=deduct_from_account, description=description,
amount=amount)
# generate slugs for the new loans
our_slugs = Slugs(current_user_id)
slug = our_slugs.add_slug(type='loan', object_id=our_loan_id, description=description)
their_slugs = Slugs(to_user)
their_slugs.add_slug(type='loan', object_id=their_loan_id, slug=slug)
their_accounts = Accounts(to_user)
# transfer money from/to respective accounts
our_accounts.modify_user_balance(account_id=deduct_from_account, amount=-float(amount))
their_accounts.modify_user_balance(amount=amount)
# fudge loan 'account' monies
our_accounts.modify_loan_balance(amount=amount, with_user_id=to_user)
their_accounts.modify_loan_balance(amount=-float(amount), with_user_id=current_user_id)
flash('Loan given')
else: error = 'Not a valid source account'
else: error = 'Not a valid date'
else: error = 'Not a valid amount'
# fetch users from connections from us
our_users = Users(current_user_id)
users = our_users.get_connections()
accounts = our_accounts.get_accounts()
return render_template('admin_give_loan.html', **locals())
def post(self):
args = parser.parse_args()
user = Users(username=args.username, email=args.email)
db.session.add(user)
db.session.commit()
db.session.remove()
return handle_success(message='add success', code='10201')
def del_repo(git_name, git_repository_blog):
args = request.args.get('access_token')
if not args:
return jsonify({'access_token': args})
git_access = GitAccess(git_name, git_repository_blog, args)
data = git_access.get_all_posts()
users_list = Users(git_name, git_repository_blog)
session_git = users_list.open_base()
users = session_git.query(Users)
query_fav = session_git.query(Favorites).filter(
Favorites.user_name == git_name.lower())
for one_fav in query_fav:
session_git.delete(one_fav)
if data.status_code == 200:
for dir_ in data.json():
git_access.del_one_post(dir_['sha'], dir_['path'])
for user in users:
if user.user_name == git_name.lower(
) and user.user_repo_name == git_repository_blog.lower():
session_git.delete(user)
session_git.commit()
session_git.close()
git_access.del_branch()
remove_files(git_name, git_repository_blog)
return '', 200
else:
for user in users:
if user.user_name == git_name.lower(
) and user.user_repo_name == git_repository_blog.lower():
session_git.delete(user)
session_git.commit()
session_git.close()
git_access.del_branch()
remove_files(git_name, git_repository_blog)
return '', 200
def dummy_user():
"""
A fixture that creates and saves a user to the database that is to be used for testing purposes
"""
user = Users("User", "*****@*****.**", Users.generate_hash("wfnbqk".encode("utf8")).decode("utf8"), True, True)
user.save()
user.commit()
return user
def create_user(user):
sql = "Insert into banking.users Values(default,%s,%s,%s) RETURNING *"
cursor = connection.cursor()
cursor.execute(sql, (user.username, user.first_name, user.last_name))
connection.commit()
record = cursor.fetchone()
new_user = Users(record[0], record[1], record[2], record[3])
return new_user
def __init__(self, *args, **kwargs):
super(LoginWidget, self).__init__(*args, **kwargs)
uic.loadUi(self._path, self)
self.show()
self.users = Users()
self.sign_in.clicked.connect(self.handle_sign_in)
self.sign_up.clicked.connect(self.handle_sign_up)
def signup():
data = request.get_json()
hashed_password = generate_password_hash(data["password"])
new_user = Users(name=data["name"], password=hashed_password)
new_user.save()
return jsonify({"message": "registered successfully"})
