def create():
user = Users()
home = HomeControllers()
if request.method == 'GET':
return str(user.query.first().name)
elif request.method == 'POST':
return home.create()
def users_create(account=None):
account_id = get_jwt_identity()
account = Accounts.query.get(account_id)
if not account:
return abort(401, description="Account not found")
users_fields = user_schema.load(request.json)
user = Users.query.get(account_id)
if not user:
new_user = Users()
new_user.username = users_fields["username"]
new_user.fname = users_fields["fname"]
new_user.lname = users_fields["lname"]
new_user.account_active = users_fields["account_active"]
account.users.append(new_user)
db.session.add(new_user)
db.session.commit()
return jsonify(user_schema.dump(new_user))
else:
return abort(401, description='User Profile already exists')
def process(self, request, session):
try:
if session['user_login']:
return redirect('/main')
except KeyError:
pass
if (request.method == 'POST'):
keys = [
'email', 'fname', 'lname', 'pass', 'rpass', 'gender', 'ph',
'add', 'city'
]
_signup_parameters = {x: request.values.get(x) for x in keys}
validateError = self.__validate(_signup_parameters)
userObj = Users()
if validateError == None:
if (userObj.find({
'email': _signup_parameters['email']
}).count() > 0):
return render_template('signup.html',
warn={
'warning': True,
'msg':
"Email Address Already Exist"
})
userObj.insert(_signup_parameters)
#session['user_login']=_signup_parameters['email']
return render_template('signupdone.html')
else:
return render_template('signup.html',
warn={
'warning': True,
'msg': 'validateError'
})
else:
return render_template('signup.html', warn={'warning': False})
def post(self):
parser.add_argument('username',
help='This field cannot be blank',
required=True)
parser.add_argument('password',
help='Please enter at least 6 characters',
required=True)
parser.add_argument('email')
parser.add_argument('mobile_number')
parser.add_argument('title')
parser.add_argument('name')
data = parser.parse_args()
profile_rating = UserHelper.calulateUserRating()
new_user = Users(username=data['username'],
password=bcrypt.hashpw(
data['password'].encode('utf-8'),
bcrypt.gensalt()),
email=data['email'],
mobile_number=data['mobile_number'],
title=data['title'],
name=data['name'],
profile_completness=1,
profile_rating=profile_rating)
try:
new_user.save()
return {
'message': 'User {} was created'.format(data['username'])
}, 200
except Exception as ex:
template = "{0}:{1!r}"
message = template.format(type(ex).__name__, ex.args)
return {'error': message}, 500
def delete_data(self):
id = request.form['id']
users = Users()
usr = users.query.filter_by(id=id).first()
db.session.delete(usr)
db.session.commit()
return redirect('/')
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 __init__(self,
num_topics,
type="R",
explore_val=0,
seen_threshold=0,
sigval_b=0,
is_profit=False):
model = TopicModel("topic_modeling/tweets.csv")
model.getTopStopWords(num_topics)
self.topics = model.topStopwords
self.users = Users(self.topics,
type,
explore_val=explore_val,
seen_threshold=seen_threshold,
sigval_b=sigval_b)
self.tweets = Tweets()
self.tweets.add_tweets()
self.recommender = RecommenderSystem()
profits = np.random.random(num_topics)
if is_profit:
self.profit = profits
else:
self.profit = np.ones(num_topics)
def signup():
if request.method == 'POST':
FN = request.form['FN']
LN = request.form['LN']
PH = request.form['PH']
EM = request.form['EM']
PW = request.form['PW']
CPW = request.form['CPW']
if PW == CPW:
new_user = Users(Fname=FN,
Lname=LN,
Phone=PH,
Email=EM,
UPassword=PW)
session.add(new_user)
session.commit()
else:
print("Passwords don't match!")
return
return render_template('login.html')
def post(self):
users = Users.Users().query(Users.Users.email == self.session['email']).get()
users.firstName = self.request.get('firstname')
users.lastName = self.request.get('lastname')
users.password = self.request.get('password')
users.email = self.request.get('email')
users.put()
self.redirect('/home')
def post(self):
new_user = Users.Users()
new_user.firstName = self.request.get('firstname')
new_user.lastName = self.request.get('lastname')
new_user.email = self.request.get('email')
new_user.password = self.request.get('password')
new_user.put()
self.redirect('/')
def update(self, id):
users = Users()
usr = users.query.filter_by(id=id).first()
usr.name = request.form['name']
usr.username = request.form['username']
usr.password = request.form['password']
db.session.commit()
return redirect('/')
def create(self):
username = request.form['username']
password = request.form['password']
name = request.form['name']
users = Users(name=name, username=username, password=password)
db.session.add(users)
db.session.commit()
return redirect('/')
def register():
if request.method == 'GET':
return render_template('register.html')
user = Users(request.form['username'], request.form['password'], request.form['email'])
db.session.add(user)
db.session.commit()
return redirect(url_for('login'))
def edit(self, id):
users = Users()
usr = users.query.filter_by(id=id).first()
data = {
'username': usr.username,
'password': usr.password,
'name': usr.name,
'id': usr.id
}
return render_template('page/home.html', data=data)
def auth_register():
user_fields = user_schema.load(request.json)
user = Users.query.filter_by(email=user_fields["email"]).first()
if user:
return abort(400, description="User already")
user = Users()
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 add_user(request):
if request.get_json()['email'] != "" and not re.search(
email_regex,
request.get_json()['email']) or not request.get_json(
)['phone_number'].isdigit():
return bad_request('wrong arguments')
user = Users(request.get_json()['name'].lower(),
request.get_json()['email'],
request.get_json()['phone_number'],
hash_string(request.get_json()['password']))
globalDB = GlobalDB(request.get_json()['name'].lower(),
request.get_json()['email'],
request.get_json()['phone_number'],
0,
isUser=globaldb_is_user['user'])
db.session.add(user)
db.session.add(globalDB)
db.session.commit()
return jsonify({'user': user.serialize}), 201
def seed_db():
from models.Profiles import Profiles
from faker import Faker
from models.Users import Users
from main import bcrypt
from models.Post import Post
import random
faker = Faker()
profiles = []
true_or_false = [True, False]
posts = []
for i in range(10):
user = Users()
user.email = f"test{i}@test.com"
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
db.session.add(user)
#accounts.append(user)
db.session.commit()
for i in range(10):
profile = Profiles()
profile.username = faker.name()
profile.fname = faker.first_name()
profile.lname = faker.last_name()
profile.account_active = faker.boolean()
profile.user_id = i + 1
db.session.add(profile)
profiles.append(profile)
db.session.commit()
for i in range(30):
new_post = Post()
new_post.post_name = faker.name()
new_post.post_description = faker.catch_phrase()
new_post.profile_id = random.choice(profiles).profileid
posts.append(new_post)
db.session.add(new_post)
db.session.commit()
print("Tables seeded")
def add_user():
userInfo = session.get('userProfile', 'not set')
if userInfo['role'] !='admin':
abort(401)
name = request.form.get('name', '')
email = request.form.get('email', '')
role = request.form.get('role', '')
create_date = DATE
new_id = db.session.query(func.max(Users.users_id))
if new_id[0][0] == None:
new_id[0][0]=0
user = Users(new_id[0][0]+1,email,name,name,role,create_date)
try:
user.insert()
except:
print(sys.exc_info())
abort(500)
return redirect(url_for('get_all_users'))
def add_user(user_id, chat_id, first_name, last_name, username, is_bot,
language_code, start_message_id):
try:
session.commit()
user = session.query(Users) \
.filter(Users.user_id == user_id) \
.all()
if len(user) == 0:
user = Users(user_id, chat_id, first_name, last_name, username,
is_bot, language_code)
session.add(user)
session.commit()
return 1
else:
return 0
except:
session.rollback()
print(sys.exc_info())
def create_user():
request = json.loads(flaskRequest.data)
userExists = Users.objects(username=request['username']).first()
if userExists:
return 'Username already in use', 400
hashProvider = HashProvider()
encryptedPassword = hashProvider.encrypt(request['password'])
user = Users(name=request['name'],
username=request['username'],
password=encryptedPassword,
privileges=request['privileges'],
imageUrl=f'{bucketURL}/avatars/standard-picture.jpg',
imageKey='standard')
user.save()
return jsonify({"data": user})
def auth_register():
email = request.form.get('email')
password = request.form.get('password')
#user_fields = user_schema.load(request.json)
user = Users.query.filter_by(email=email).first()
if user:
return abort(400, description="User already")
user = Users()
#user.email = user_fields["email"]
# user.password = bcrypt.generate_password_hash(user_fields["password"]).decode("utf-8")
user.email = email
user.password = bcrypt.generate_password_hash(password).decode("utf-8")
db.session.add(user)
db.session.commit()
#return jsonify(user_schema.dump(user))
return redirect(url_for('auth.login')) #added
def signup():
if request.method == 'POST':
data = request.get_json(force=True)
print(data)
q = Users.query.filter_by(email=data['email']).first()
print(q)
if q is None:
user = Users(email=data['email'],
pwd=data['pwd'],
gender=data['gender'],
nickname=data['nickname'])
db.session.add(user)
db.session.commit()
subject = 'verify from circles'
rec = [data['email']]
content = {
'url': 'steins.xin:8001/auth/verify/' + user.cyphered_email,
'nickname': user.nickname
}
send_mail(subject=subject, recv=rec, content=content)
return jsonify(dict(status=1, type=-1, is_new=-1))
else:
return jsonify(dict(status=0, type=1, is_new=-1))
def getUserFName(__user_parameters):
userObj = Users()
return userObj.find(__user_parameters)
def index(self):
users = Users()
usr = users.query.all()
return render_template('page/home.html', users=usr)
def get(self):
path = os.path.join(os.path.dirname(__file__), '../templates/main.html')
users = Users().query(Users.Users.email == self.session.get('email')).get()
self.response.out.write(template.render(path, {'users':users}))
def seed_db():
from models.Profiles import Profiles
from faker import Faker
from models.Users import Users
from main import bcrypt
from models.Post import Post
from models.Messages import Messages
import random
faker = Faker()
profiles = []
true_or_false = [True, False]
posts = []
for i in range(10):
user = Users()
user.email = f"test{i}@test.com"
user.password = bcrypt.generate_password_hash("123456").decode("utf-8")
db.session.add(user)
#accounts.append(user)
db.session.commit()
for i in range(10):
profile = Profiles()
profile.username = faker.name()
profile.fname = faker.first_name()
profile.lname = faker.last_name()
profile.account_active = faker.boolean()
profile.user_id = i + 1
profile.github = faker.name()
profile.front_end = random.choice(true_or_false)
profile.back_end = random.choice(true_or_false)
profile.full_stack = random.choice(true_or_false)
db.session.add(profile)
profiles.append(profile)
db.session.commit()
for i in range(30):
new_post = Post()
new_post.post_name = faker.name()
new_post.post_description = faker.catch_phrase()
new_post.account_active = random.choice(true_or_false)
new_post.front_end = random.choice(true_or_false)
new_post.back_end = random.choice(true_or_false)
new_post.full_stack = random.choice(true_or_false)
new_post.completed = random.choice(true_or_false)
new_post.post_github = faker.url()
new_post.profile_id = random.choice(profiles).profileid
posts.append(new_post)
db.session.add(new_post)
db.session.commit()
for i in range(50):
new_message = Messages()
new_message.post_id = random.choice(posts).postid
new_message.profile_id = random.choice(profiles).profileid
new_message.messages = faker.catch_phrase()
new_message.timestamp = faker.date_between(start_date="-1y",
end_date="+1y")
db.session.add(new_message)
db.session.commit()
print("Tables seeded")
def checkUserExists(__user_parameters):
userObj = Users()
return userObj.find(__user_parameters).count() > 0
def get(self):
path = os.path.join(os.path.dirname(__file__), '../templates/editPost.html')
users = Users.Users().query(Users.Users.email == self.request.get('email')).get()
templates_var = {'users' : users}
self.response.out.write(template.render(path, templates_var))