def seed_db():
from models.Item import Item
from models.User import User
from models.Order import Order
from models.OrderShipping import OrderShipping
from main import bcrypt
from faker import Faker
import random
faker = Faker()
for i in range(3):
user = User()
user.email = f"test{i}@test.com"
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
db.session.add(user)
admin = User()
admin.email = "*****@*****.**"
admin.password = bcrypt.generate_password_hash("123456").decode("utf-8")
admin.admin = True
db.session.add(admin)
db.session.commit()
for i in range(10):
item = Item()
item.name = faker.currency_name()
item.description = faker.paragraph(nb_sentences=3)
item.price = 53.25
db.session.add(item)
db.session.commit()
ordershipping = []
for i in range(5):
shipping = OrderShipping()
shipping.first_name = faker.first_name()
shipping.last_name = faker.last_name()
shipping.address = faker.street_address()
shipping.state = faker.city()
shipping.zip_code = faker.postcode()
db.session.add(shipping)
ordershipping.append(shipping)
db.session.commit()
orders = []
for i in range(5):
order = Order()
order.shipping_id = random.choice(ordershipping).id
db.session.add(order)
orders.append(order)
db.session.commit()
print("Tables seeded.")
def db_start():
create_engine('sqlite:///tmp/test.db', convert_unicode=True)
db.create_all()
db.session.commit()
user = models.User(
password=bcrypt.generate_password_hash('password').decode('utf-8'),
email='*****@*****.**',
admin=True)
user2 = models.User(
password=bcrypt.generate_password_hash('password').decode('utf-8'),
email='*****@*****.**',
admin=True)
db.session.add(user)
db.session.add(user2)
db.session.commit()
recipe = models.Recipe(title="Private recipe user1",
ingredients="Some ingredients",
time_needed=15,
steps="some steps",
is_public=False,
user_id=user.id,
average_score=None)
recipe2 = models.Recipe(title="Public recipe user1",
ingredients="Some ingredients",
time_needed=15,
steps="some steps",
is_public=True,
user_id=user.id,
average_score=None)
recipe3 = models.Recipe(title="Private recipe user2",
ingredients="Some ingredients",
time_needed=15,
steps="some steps",
is_public=False,
user_id=user2.id,
average_score=None)
recipe4 = models.Recipe(title="Public recipe user2",
ingredients="Some ingredients",
time_needed=15,
steps="some steps",
is_public=True,
user_id=user2.id,
average_score=None)
db.session.add(recipe)
db.session.add(recipe2)
db.session.add(recipe3)
db.session.add(recipe4)
db.session.commit()
vote1 = models.Vote(value=1, user_id=user.id, recipe_id=recipe.id)
db.session.add(vote1)
db.session.commit()
def seed_db():
"""give tables in database false data for testing purposes
"""
from models.Document import Document
from models.Authentication import User
from main import bcrypt
from faker import Faker
import random
faker = Faker()
users = []
for i in range(5):
user = User()
user.username = f"testuser{i}"
user.password = bcrypt.generate_password_hash("testpasswd").decode("utf-8")
db.session.add(user)
users.append(user)
db.session.commit()
for i in range(20):
doc = Document()
doc.docname = faker.catch_phrase()
doc.user_id = random.choice(users).id
db.session.add(doc)
db.session.commit()
print("Seeded Tables")
def auth_register():
if request.form.get("Cancel") != None:
return redirect(url_for("auth.home"))
password = request.form.get("password")
username = request.form.get("username")
# check if username or password are empty
if username == "" or password == "":
return abort(400, description="username and password must have values")
# check for spaces in usernames
if ' ' in username or ' ' in password:
return abort(
400, description="cannot put whitespaces in username or password")
# checks if user already exists
user = User.query.filter_by(username=username).first()
if user:
return abort(400, description="username already taken")
user = User()
user.username = username
user.password = bcrypt.generate_password_hash(password).decode("utf-8")
db.session.add(user)
db.session.commit()
return redirect(url_for("auth.login"))
def user_register():
user_fields = user_schema.load(request.json)
user = User.query.filter_by(email=user_fields["email"]).first()
if user:
return abort(400, description="Email already registered to an account")
try:
last_record = db.session.query(User).order_by(User.id.desc()).first()
except:
last_record = 0
user = User()
user.id = last_record.id + 1
user.displayname = user_fields["displayname"]
user.username = user_fields["username"]
user.email = user_fields["email"]
user.password = bcrypt.generate_password_hash(
user_fields["password"]).decode("utf-8")
db.session.add(user)
db.session.commit()
return jsonify(user_schema.dump(user))
def sign_up():
if len(request.form) != 0:
username = request.form.get('username')
email = request.form.get('email')
password = request.form.get('password')
print(
f'\n\n{username} just registered\nE-mail:{email}\nPassword "{password}"\n\n'
)
if len(User.query.filter_by(username=username).all()) == 0 and len(
User.query.filter_by(email=email).all()) == 0:
new_user = User(username=username,
email=email,
password=bcrypt.generate_password_hash(
password).decode('UTF-8'))
db.session.add(new_user)
db.session.commit()
login_user(new_user, remember=True)
return redirect('/')
return render_template('sign-up.html')
def seed_db():
# Seed database with example data
from models.Post import Post
from models.User import User
from main import bcrypt
from faker import Faker
import random
faker = Faker()
users = []
for i in range(5):
user = User()
user.email = f"test{i}@test.com"
user.name = faker.name()
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
user.created_at = datetime.now()
db.session.add(user)
users.append(user)
db.session.commit()
for i in range(20):
post = Post()
post.caption = faker.catch_phrase()
post.created_at = datetime.now()
post.updated_at = datetime.now()
post.total_likes = 0
post.total_comments = 0
post.user_id = random.choice(users).id
db.session.add(post)
db.session.commit()
print("Tables seeded")
def register():
if current_user.is_authenticated:
return redirect(url_for('home'))
form = RegistrationForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
# user = User(username = form.username.data, first_name = form.first_name.data, last_name = form.last_name.data,
# email = form.email.data, password = hashed_password)
flask.session['user'] = form.username.data
flask.session['first_name'] = form.first_name.data
flask.session['last_name'] = form.last_name.data
flask.session['email'] = form.email.data
flask.session['password'] = hashed_password
username = form.username.data
flash(f'Please set up your profile to create your account.', 'success')
return redirect(url_for('profile_creation', username=username))
return render_template('register.html', title='Register', form=form)
def register():
if current_user.is_authenticated:
return redirect(url_for('home'))
form = SignupForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
user = User(fullname=form.fullName.data,
username=form.username.data,
address=form.address.data,
governorate=form.gov.data,
email=form.email.data,
password=hashed_password,
user_class=form.user_class.data,
gender=form.gender.data,
phone=form.phone.data,
nat_id=form.nat_id.data)
db.session.add(user)
db.session.commit()
flash(f'Account created for {form.username.data}!', 'success')
return redirect(url_for('login'))
file = url_for('static', filename='css/main.css')
return render_template('Account.html',
file=file,
title="إنشاء حساب",
form=form)
def create_user():
data = request.get_json()
user = user_schema.dump(User.query.filter_by(email=data['email']).first())
if not data:
return make_response(jsonify({'message': 'No input data provided'})), 400
if user:
return make_response(jsonify({'message': 'User with such email already exists!'})), 400
hashed_password = bcrypt.generate_password_hash(data['password']).decode('UTF-8')
new_user = User(
contactName=data['contactName'],
password=hashed_password,
email=data['email'],
phoneNumber=data['phoneNumber']
)
if 'imageFile' in request.files:
file = request.files['imageFile']
if file.filename == '':
return redirect(request.url)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_PROFPIC_FOLDER'], filename))
new_user.imageFile = filename
db.session.add(new_user)
db.session.commit()
result = user_schema.dump(new_user)
return make_response(jsonify({'message': 'New user created!', 'user': result})), 201
def seed_db():
from models.Example import Example # Import the example model
from models.User import User # User model
from main import bcrypt # Hashing module
from faker import Faker # Import the faker module
import random
faker = Faker() # Create an instance of faker
users = [] # Initializing an empty list
# Creating 5 users and appending them to the users list
for i in range(5):
user = User()
user.email = f"test{i}@test.com"
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
db.session.add(user)
users.append(user)
db.session.commit()
for i in range(20): # 20
example = Example() # New instance of example
example.title = faker.catch_phrase() # Add a title
example.user_id = random.choice(users).id # Choosing a random user to assign the example to
db.session.add(example) # add the example to the db session
db.session.commit() # Commit all the examples to the db
print("Tables seeded")
def seed_db():
from models.Meal import Meal
from models.User import User
from main import bcrypt
from faker import Faker
import random
faker = Faker()
users = []
for i in range(5):
user = User()
user.email = f"test{i}@test.com"
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
db.session.add(user)
users.append(user)
db.session.commit()
for i in range(20):
meal = Meal()
meal.title = faker.sentence(nb_words=3)
meal.user_id = random.choice(users).id
db.session.add(meal)
db.session.commit()
print("Tables seeded")
def seed_db():
from models.Recipe import Recipe
from models.User import User
from main import bcrypt
from faker import Faker
import random
faker = Faker()
users = []
for i in range(5):
user = User()
user.email = f"test{i}@test.com"
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
db.session.add(user)
users.append(user)
db.session.commit()
for i in range(10):
recipe = Recipe()
recipe.recipe_name = faker.catch_phrase()
recipe.description = faker.catch_phrase()
recipe.user_id = random.choice(users).user_id
db.session.add(recipe)
print(f"{i + 1} recipe record(s) created")
db.session.commit()
print("Tables seeded")
def auth_register():
username = request.form.get('username')
email = request.form.get('email')
password = request.form.get('password')
user_username = Users.query.filter_by(username=username).first()
user_email = Users.query.filter_by(email=email).first()
if user_username or user_email:
flash("Username/email already exists", "info")
return redirect(url_for('auth.signup'))
elif (len(username) or len(email)) < 5 or (len(password)) < 6:
flash("Username/email/password min 6 Characters", "info")
return redirect(url_for('auth.signup'))
user = Users()
user.username = username
user.email = email
user.password = bcrypt.generate_password_hash(password).decode("utf-8")
db.session.add(user)
db.session.commit()
languages = Languages.query.all()
for lang in languages:
user_watchlist = Watchlist()
user_watchlist.user_id = user.id
user_watchlist.language_id = lang.id
db.session.add(user_watchlist)
db.session.commit()
flash("Successfuly registered! Please Log in", "info")
return redirect(url_for('users.profile', id=user.id))
def seed_db():
from models.Accounts import Accounts
from models.Users import Users
from faker import Faker
from main import bcrypt
import random
faker = Faker()
accounts = []
for i in range(10):
account = Accounts()
account.email = f"test{i}@test.com"
account.password = bcrypt.generate_password_hash("123456").decode(
"utf-8")
db.session.add(account)
accounts.append(account)
db.session.commit()
for i in range(10):
user = Users()
user.username = faker.name()
user.fname = faker.first_name()
user.lname = faker.last_name()
user.profile_pic = faker.text()
user.account_active = faker.boolean()
user.account_id = i + 1
db.session.add(user)
db.session.commit()
print("Tables seeded")
def seed_db():
from models.User import User # Importing the User model
from models.Profile import Profile # Importing the Profile model
from main import bcrypt # Hashing module for the passwords
from faker import Faker # Importing the faker module for fake data
import random # Importing random from the python standard library
faker = Faker()
users = []
for i in range(5): # Do this 5 times
user = User() # Create an user object from the User model
user.email = f"test{i+1}@test.com" # Assign an email to the user object
user.password = bcrypt.generate_password_hash("123456").decode("utf-8") # Assign ta hashed password to the user object
db.session.add(user) # Add the user to the db session
users.append(user) # Append the user to the users list
db.session.commit() # Commit the seeion to the db
for i in range(5):
profile = Profile() # Create a profile object from the Profile model
profile.username = faker.first_name() # Add a username to the profile object
profile.firstname = faker.first_name() # Add a firstname to the profile object
profile.lastname = faker.last_name() # Add a lastname to the profile object
profile.user_id = users[i].id # Add a user_id to the profile object. This comes from real ids from the users list
db.session.add(profile) # Add the profile to the session
db.session.commit() # Commit the session to the database
print("Tables seeded")
def seed_db():
from models.calorie_count import Nutrient_DB
from models.user import User
from main import bcrypt
from faker import Faker
import random
fake = Faker()
length = 10
for i in range(length):
user = User()
user.username = f"user{i}"
user.email = f"test{i}@test.com"
user.password = bcrypt.generate_password_hash("123").decode("utf-8")
user.first_name = fake.first_name()
user.last_name = fake.first_name()
user.phone = 123345334
db.session.add(user)
db.session.commit()
for i in range(length):
calorie = Nutrient_DB()
calorie.name = fake.first_name()
calorie.calories = random.randint(50, 400)
calorie.protein = random.randint(0, 10)
calorie.fat = random.randint(0, 10)
calorie.carb = random.randint(0, 10)
calorie.date = fake.date()
calorie.user_id = random.randint(1, 9)
db.session.add(calorie)
db.session.commit()
print("Tables seeded")
def invite(name, h):
if current_user.is_authenticated():
return redirect(url_for('index'))
if not Invite.confirm_invite(name, h):
flash(config.messages.BAD_INVITE, category='red')
return redirect(url_for('index'))
register = Register(request.form)
register._action = request.path
if request.method == 'POST' and register.validate():
user = User(
username=name,
h=bcrypt.generate_password_hash(register.password.data),
max_load=config.AUTH_PAYLOAD
).save()
Invite.delete_invite(name, h)
flash('You are now registered.')
return redirect(url_for('login'))
return render_template('register.html', title='You\'re Invited', form=register)
def seed_db():
from models.User import User
from models.Settlement import Settlement
from main import bcrypt
from faker import Faker
import random
faker = Faker()
#Initial Setup
users = []
#Users/Settlements
for i in range(1, 5):
user = User()
settlement = Settlement()
user.username = f"testusername{i}"
user.password = bcrypt.generate_password_hash("1234").decode("utf-8")
settlement.user_id = faker.random_int(min=1, max=4)
settlement.name = f"testsettlementname{i}"
settlement.saleprice = faker.random_int(min=300000, max=1000000)
settlement.deposit = faker.random_int(min=15000, max=20000)
settlement.settdate = "2021-06-06"
print(f"{i} Users & Settlements Created")
db.session.add(user)
db.session.add(settlement)
users.append(user)
db.session.commit()
print("Tables seeded")
def register():
if request.method == 'POST':
new_username = request.form.get('username')
new_password = bcrypt.generate_password_hash(request.form.get('password')).decode('utf-8')
new_password_verify = request.form.get('password_verify')
new_email = request.form.get('email')
try:
sprawdzanie_uzytkownika_login = User.query.filter_by(username=new_username).first()
if sprawdzanie_uzytkownika_login is not None:
flash("Podany login już istnieje", 'danger')
return render_template('register.html',username=new_username,email=new_email)
sprawdzanie_uzytkownika_email = User.query.filter_by(email=new_email).first()
if sprawdzanie_uzytkownika_email is not None:
flash("Podany przez Ciebie adres e-mail już istnieje", 'danger')
return render_template('register.html',username=new_username,email=new_email)
if not bcrypt.check_password_hash(new_password, new_password_verify):
flash("Podane hasła się nie zgadzają!", 'danger')
return render_template('register.html',username=new_username,email=new_email)
new_user = User(username=new_username, password=new_password, email=new_email)
db.session.add(new_user)
db.session.commit()
return redirect('/login')
except ServerError as err:
flash(str(err), 'danger')
return render_template('register.html')
return render_template('register.html')
def seed_db():
from models.Budget import Budget
from models.User import User
from main import bcrypt
from faker import Faker
import random
faker = Faker()
users = []
for i in range(5):
user = User()
user.username = f"tester{i}"
user.email = f"test{i}@test.com"
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
db.session.add(user)
users.append(user)
db.session.commit()
for i in range(10):
budget = Budget()
budget.name = faker.catch_phrase()
budget.user_id = random.choice(users).id
db.session.add(budget)
db.session.commit()
print("Tables seeded")
def edit_password():
if request.method == 'POST':
old_password = request.form.get('old_password')
new_password = bcrypt.generate_password_hash(request.form.get('new_password')).decode('utf-8')
new_password_verify = request.form.get('new_password_verify')
try:
username=session['username']
sprawdzanie_uzytkownika_haslo = User.query.filter_by(username=username).first()
if not bcrypt.check_password_hash(sprawdzanie_uzytkownika_haslo.password, old_password):
flash("Podaleś błędne stare hasło!", 'danger')
return render_template('edit_password.html')
if not bcrypt.check_password_hash(new_password, new_password_verify):
flash("Podane hasła się nie zgadzają!", 'danger')
return render_template('edit_password.html')
sprawdzanie_uzytkownika_haslo.password = new_password
db.session.commit()
flash("Hasło zmienione", 'success')
return redirect('/login')
except ServerError as err:
flash(str(err), 'danger')
return render_template('edit_password.html')
return render_template('edit_password.html')
def user_create():
user_fields = user_schema.load(request.json)
user_with_same_email = User.query.filter_by(email=user_fields["email"]).first()
user_with_same_username = User.query.filter_by(username=user_fields["username"]).first()
if user_with_same_email:
return abort(400, description="Username already registered")
if user_with_same_username:
return abort(400, description="Email already registered")
user = User()
user.username = user_fields["username"]
user.first_name = user_fields["first_name"]
user.last_name = user_fields["last_name"]
user.created_at = user_fields["created_at"]
user.dob = user_fields["dob"]
user.email = user_fields["email"]
user.mobile = user_fields["mobile"]
user.city = user_fields["city"]
user.country = user_fields["country"]
user.password = bcrypt.generate_password_hash(user_fields["password"]).decode("utf-8")
db.session.add(user)
db.session.commit()
return jsonify(user_schema.dump(user))
def seed_db():
from models.Book import Book
from models.User import User
from main import bcrypt
from faker import Faker
import random
faker = Faker()
users = []
for i in range(5):
user = User()
user.email = f"test{i}@test.com"
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
db.session.add(user)
users.append(user)
db.session.commit()
for i in range(20):
book = Book()
book.title = faker.catch_phrase()
book.user_id = random.choice(users).id
db.session.add(book)
db.session.commit()
print("Tables seeded")
def post(self):
args = self.parser.parse_args()
try:
student = StudentModel.query.get(args['id'])
if not student:
student = StudentModel.query.filter_by(
email=args['email']).first()
if not student:
args['password'] = bcrypt.generate_password_hash(
args['password']).decode('utf8')
student = StudentModel(**args)
student.save()
return {'message': 'Student saved sucessfully'}, 201
return {'message': 'Student email already registered'}, 400
return {'message': "Student id already registered"}, 400
except Exception as e:
print(e)
return {'message': 'Something got wrong'}, 500
def reset_password(self):
user = self.users_by_hash().one()
user.password = bcrypt.generate_password_hash(
self.password).decode('utf-8')
user.password_reset_hash = None
user.password_reset_sent = None
db.commit()
self.send_notification(user)
def db_start():
create_engine('sqlite:///tmp/test.db', convert_unicode=True)
db.create_all()
db.session.commit()
user_1 = models.User()
user_1.username = "******"
user_1.password = bcrypt.generate_password_hash('pppp1234')
user_1.email = '*****@*****.**'
user_1.admin = True
user_1.poweruser = True
db.session.add(user_1)
db.session.commit()
user_2 = models.User()
user_2.username = "******"
user_2.password = bcrypt.generate_password_hash('ewelina1')
user_2.email = '*****@*****.**'
user_2.admin = False
user_2.poweruser = False
db.session.add(user_2)
db.session.commit()
user_3 = models.User()
user_3.username = "******"
user_3.password = bcrypt.generate_password_hash('qwertyuiop')
user_3.email = '*****@*****.**'
user_3.admin = True
user_3.poweruser = True
db.session.add(user_3)
db.session.commit()
user_4 = models.User()
user_4.username = "******"
user_4.password = bcrypt.generate_password_hash('admin')
user_4.email = '*****@*****.**'
user_4.admin = True
user_4.poweruser = True
db.session.add(user_4)
db.session.commit()
'''
def register():
form = RegistrationForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
new_user = User(email=form.email.data, password=hashed_password)
db.session.add(new_user)
db.session.commit()
flash('Account created! You may now login.', 'success')
return redirect(url_for('users.login'))
return render_template('register.html', title='Register', form=form)
def index():
lform = login_form()
rform = register_form()
nform = newpost_form()
if lform.lsubmit.data and lform.validate_on_submit():
user = User.query.filter_by(email=lform.lemail.data).first()
if user and bcrypt.check_password_hash(user.password,
lform.lpassword.data):
login_user(user)
nextpage = request.args.get("next")
flash("شما وارد شدید", category="success")
if nextpage:
return redirect(nextpage)
else:
return redirect(url_for("index"))
else:
flash("ایمیل و پسورد را دوباره چک کنید", category="danger")
return redirect(url_for("index"))
if rform.rsubmit.data and rform.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(rform.rpassword.data)
user = User(firstname=rform.firstname.data,
lastname=rform.lastname.data,
email=rform.remail.data,
password=hashed_password)
db.session.add(user)
db.session.commit()
# send_email(user)
flash("ثبت نام شما با موفقیت انجام شد.", category="success")
return redirect(url_for("index"))
if current_user.is_authenticated == True:
postslen = len(current_user.posts)
page = request.args.get("page", 1, int)
posts = Post.query.filter_by(author=current_user).order_by(
Post.id.desc()).paginate(page=page, per_page=5)
else:
postslen = 0
posts = None
if nform.nsubmit.data and nform.validate_on_submit():
post = Post(title=nform.title.data,
date=nform.date.data,
time=nform.time.data,
user_id=current_user.id)
db.session.add(post)
db.session.commit()
flash("پست شما افزوده شد", category="success")
return redirect(url_for("index"))
return render_template("index.html",
lform=lform,
rform=rform,
nform=nform,
title="صفحه اصلی",
posts=posts,
postslen=postslen)
def __init__(self, fullname, email, age, password, gender, admin=False):
self.id = str(uuid.uuid4())
self.fullname = fullname
self.email = email
self.age = age
self.password = bcrypt.generate_password_hash(
password, app.config.get('BCRYPT_LOG_ROUNDS')
).decode()
self.gender = gender
self.registered_on = datetime.datetime.now()
self.admin = admin
def register():
if current_user.is_authenticated:
return redirect(url_for('home'))
form = RegistrationForm()
if form.validate_on_submit():
hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')
user = User(username = form.username.data, email = form.email.data, password=hashed_password)
db.session.add(user)
db.session.commit()
flash(f'Account created. Now you are able to log in!', 'success')
return redirect(url_for('login'))
return render_template('register.html', title='Login', form = form)
from main import create_user, bcrypt
from getpass import getpass
name = raw_input('Name : ')
access = 'superadmin'
email = raw_input("Email : ")
for i in range(3):
pwd = getpass()
confirmpwd = getpass("Confirm Password : "******"Super User created successfully !!"
break
else:
print "Error creating super user contact the admin :("
break
else:
print "Error Passwords don't match try again !!"
