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 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 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 delete(self, user_id=None):
"""データ削除."""
if not user_id:
return ({'code': 404, 'message': 'no target data'}, 404)
try:
Users_DB.delete({'user_id': user_id})
except NoResultFound:
return ({'code': 404, 'message': 'no target data'}, 404)
return {'code': 200, 'message': 'ok'}
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 post(self, user_id=None):
"""データ更新."""
if not user_id:
return ({'code': 404, 'message': 'no target data'}, 404)
j_data = request.json
try:
upd_data = {}
if j_data.get('user_name'):
upd_data['user_name'] = j_data.get('user_name')
if j_data.get('group_id'):
upd_data['group_id'] = j_data.get('group_id')
Users_DB.update({'user_id': user_id}, upd_data)
except NoResultFound:
return ({'code': 404, 'message': 'no target data'}, 404)
return {'code': 200, 'message': 'ok'}
def create():
user = Users()
home = HomeControllers()
if request.method == 'GET':
return str(user.query.first().name)
elif request.method == 'POST':
return home.create()
def get_user_object_from_user_id(user_id):
return json.dumps(
Users.query(Users.key == ndb.Key(urlsafe=user_id)).get(projection=[
Users.slug, Users.last_name, Users.first_name,
Users.firebase_uid, Users.email
]).to_dict(),
default=str)
def post(self, userId):
parser.add_argument("general_question_answers",
action="append",
required=True)
data = parser.parse_args()
try:
print(data)
currentUser = Users.objects(id=userId).first()
print(currentUser)
if not currentUser:
return {'error': 'User doesn\'t exist'}, 404
profile_rating = UserHelper.calulateUserRating(currentUser, 1)
updated_user = currentUser.update(
general_question_answers=data['general_question_answers'],
profile_completness=currentUser.profile_completness + 1,
profile_rating=profile_rating)
return {
'message':
'general question answers has been added for {}'.format(
currentUser['username'])
}, 200
except Exception as ex:
print(ex)
template = "{0}:{1!r}"
message = template.format(type(ex).__name__, ex.args)
return {'error': message}, 500
def put(self, userId):
parser.add_argument('duration_of_stay_at_address', required=True)
parser.add_argument('profile_picture', required=True)
parser.add_argument('postcode', required=True)
parser.add_argument('current_address', required=True)
parser.add_argument('home_number', required=True)
parser.add_argument('gender', required=True)
parser.add_argument('nationality', required=True)
parser.add_argument('date_of_birth', required=True)
data = parser.parse_args()
try:
currentUser = Users.objects(id=userId).first()
if not currentUser:
return {'error': 'User doesn\'t exist'}, 404
currentUser.personal_details.update(
duration_of_stay_at_address=data[
'duration_of_stay_at_address'],
postcode=data['postcode'],
current_address=data['current_address'],
home_number=data['home_number'],
gender=data['gender'],
nationality=data['nationality'],
date_of_birth=data['date_of_birth'],
)
return {
'message':
'{}`s personal details have been updated'.format(
currentUser['username'])
}, 200
except Exception as ex:
print(ex)
template = "{0}:{1!r}"
message = template.format(type(ex).__name__, ex.args)
return {'error': message}, 500
def authenticate():
request = json.loads(flaskRequest.data)
user = Users.objects(username=request['username']).first()
if not user:
return 'Wrong username. Try again.', 400
hashProvider = HashProvider()
passwordMatch = hashProvider.compareHashs(request['password'],
user['password'])
if not passwordMatch:
return 'Wrong password. Try again.', 400
tokenExists = Tokens.objects(user=user['id']).first()
if (tokenExists):
tokenExists.delete()
token = Tokens(token=f'{uuid4()}',
createdAt=f'{dt.now()}',
user=user['id'])
token.save()
return jsonify({"token": token["token"], "user": user})
def put(self, userId):
parser.add_argument("fullname", required=True)
parser.add_argument("contact_number", required=True)
parser.add_argument("relation", required=True)
data = parser.parse_args()
try:
currentUser = Users.objects(id=userId).first()
if not currentUser:
return {'error': 'User doesn\'t exist'}, 404
print(currentUser)
currentUser.emergency_contact_details.update(
fullname=data['fullname'],
contact_number=data['contact_number'],
relation=data['relation'])
return {
'message':
'{} emergency contact has been updated'.format(
currentUser['username'])
}, 200
except Exception as ex:
print(ex)
template = "{0}:{1!r}"
message = template.format(type(ex).__name__, ex.args)
return {'error': message}, 500
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):
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)
data = parser.parse_args()
user = Users.objects(username=data['username']).first()
if not user:
return {
'error': 'User {} doesn\'t exist'.format(data['username'])
}, 404
user = json.loads(user.to_json())
if bcrypt.checkpw(data['password'].encode('utf-8'),
user["password"].encode('utf-8')):
access_token = create_access_token(identity=data['username'])
refresh_token = create_refresh_token(identity=data['username'])
return {
'message': 'Logged in as {}'.format(user["username"]),
'access_token': access_token,
'refresh_token': refresh_token
}, 200
else:
return {'error': 'Unauthorized'}, 401
return data
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 uploadUserPicture():
userAuthenticated, userData = isAuthenticated(
flaskRequest.headers['authorization'])
if userAuthenticated:
user = Users.objects(id=userData['id']).first()
if not user:
return "No user was found with that ID.", 400
s3 = S3()
if user['imageKey'] != 'standard':
print(user["imageKey"])
print(type(user["imageKey"]))
s3.deleteFile(user["imageKey"])
image = flaskRequest.files['image']
hashedImageName = f'{uuid4()}-{image.filename.replace(" ", "").replace("(", "").replace(")", "")}'
imageKey = f'avatars/{hashedImageName}'
tmpPath = f'{rootDir}/tmp/{hashedImageName}'
image.save(tmpPath)
s3.uploadFile(tmpPath, f'avatars/{hashedImageName}')
os.remove(tmpPath)
user['imageKey'] = imageKey
user['imageUrl'] = f'{bucketURL}/avatars/{hashedImageName}'
user.save()
return jsonify({"data": user})
else:
return "Token missing or expired. Please login again.", 403
def post(self, userId):
parser.add_argument("fullname", required=True)
parser.add_argument("contact_number", required=True)
parser.add_argument("relation", required=True)
data = parser.parse_args()
try:
currentUser = Users.objects(id=userId).first()
if not currentUser:
return {'error': 'User doesn\'t exist'}, 404
print(currentUser)
emergencyContact = EmergencyContact(
fullname=data['fullname'],
contact_number=data['contact_number'],
relation=data['relation'])
emergency_contact = emergencyContact.save()
profile_rating = UserHelper.calulateUserRating(currentUser, 1)
updated_user = currentUser.update(
emergency_contact_details=emergency_contact,
profile_completness=currentUser.profile_completness + 1,
profile_rating=profile_rating)
print(updated_user)
return {
'message':
'{} emergency contact has been added'.format(
currentUser['username'])
}, 200
except Exception as ex:
print(ex)
template = "{0}:{1!r}"
message = template.format(type(ex).__name__, ex.args)
return {'error': message}, 500
def dispatch(self):
# Get a session store for this request.
self.session_store = sessions.get_store(request=self.request)
cookie = self.request.cookies.get('remember_me2')
if not self.session.get("email"):
if cookie:
chashed, cemail, key = cookie.split("&")
result = self.check_password(chashed, cemail)
if result:
query = Users.query(Users.email == cemail)
user = query.get()
if user:
self.set_profile_image(user.key.urlsafe())
check_cookie = LoginHistory.query(
ndb.AND(LoginHistory.user_id == user.key.urlsafe(),
LoginHistory.cookie_key == key),
ancestor=HISTORY_PARENT_KEY).get()
if check_cookie:
self.session['email'] = cemail
self.session['name'] = user.first_name.title(
) + " " + user.last_name.title()
self.session['first_name'] = user.first_name.title(
)
self.session['user_id'] = user.key.urlsafe()
self.session['register_type'] = user.register_type
self.session[
'Profile_url'] = self.get_profile_image()
self.session['user_type'] = user.user_type
check_cookie.last_active = time.time()
check_cookie.put()
unauthorized_routes = [
"/", "/log-in", "/sign-up", "/help", "/teach", "/social-login",
"/reset-password", "/reset-password-email", "/search",
"/map-listings", "/card-listings", "/listing", "/delete-index"
]
# print(self.request.path)
if self.request.path in unauthorized_routes:
# print(self.request.path)
pass
elif "/listing" in self.request.path:
# print(self.request.path)
pass
else:
if self.session.get("user_id"):
chashed, cemail, key = cookie.split("&")
session_check = LoginHistory.query(
LoginHistory.cookie_key == key).get()
if not session_check:
self.redirect('/logout')
if not self.session.get("email"):
self.redirect('/log-in')
try:
# Dispatch the request.
webapp2.RequestHandler.dispatch(self)
finally:
# Save all sessions.
self.session_store.save_sessions(self.response)
def get(self, user_id=None):
"""データ取得."""
if user_id:
conditions = {'user_id': user_id}
else:
conditions = {}
user_data = Users_DB.selects(conditions)
return {'code': 200, 'user_data': user_data}
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 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 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 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 test_get_predict(self):
from models.Users import Users
from predict.get_predict import get_predict
user = Users.get()
res = get_predict(user, n=10)
self.assertIsInstance(res, list)
self.assertEqual(len(res), 10)
self.assertIsInstance(res[0], int)
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 put(self, user_id=None):
"""データ登録."""
if user_id:
return ({'code': 400, 'message': 'can not set user_id'}, 400)
j_data = request.json
must_keys = ['user_name', 'group_id']
for key in must_keys:
if key not in j_data.keys():
return ({
'code': 400,
'message': '{} must set in json'.format(key)
}, 400)
ins_data = {
'user_id': j_data.get('user_id', None),
'user_name': j_data.get('user_name'),
'group_id': j_data.get('group_id'),
}
Users_DB.inserts([ins_data])
return {'code': 200, 'message': 'ok'}
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 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)
