def sign_up():
form = {}
form['name'] = request.args.get("name")
form['username'] = request.args.get("username")
form['phone'] = request.args.get("phone")
form['password'] = request.args.get("password")
form['country'] = request.args.get("country")
form['state'] = request.args.get("state")
form['city'] = request.args.get("city")
print(form)
print(type(form))
#return(jsonify(form))
un = form['username']
ob = repo.OhlcRepo()
user = ob.find_record_with_limit(collection_name="users",
query={"username": str(un)},
limit=1)
print(user)
if not user:
""" Successful signup """
""" OTP Verification for email """
""" """
o = SendOTPOverEmail(form['username'])
form['email_otp'] = o
form['email_verified'] = False
form['searched_keywords'] = []
ob.insert_record(collection_name="users",
query={},
insert_doc={"$set": form})
return (jsonify({'data': 'Success', 'error': None}))
else:
""" Exception msg: User already exists """
return (jsonify({'data': None, 'error': 'username already exists'}))
def ret_course():
title = request.args.get("title")
source = request.args.get("source")
ob = repo.OhlcRepo()
res = ob.find_record_with_limit(collection_name="courses",
query={
"course_title": title,
"course_source": source
},
limit=1)
res[0]['_id'] = str(res[0]['_id'])
return (jsonify({'data': res[0], 'error': None}))
def quiz(domain):
ob = repo.OhlcRepo()
records = list(ob.find_record_with_limit('quiz', {'domain': domain}, 9))
results = {'beginner': [], 'intermediate': [], 'advanced': []}
for record in records:
record['_id'] = str(record['_id'])
if record['level'] == 1:
results['beginner'].append(record)
if record['level'] == 2:
results['intermediate'].append(record)
if record['level'] == 3:
results['advanced'].append(record)
results['type'] = 'quiz'
return create_json(results)
def first_time_quiz():
data = request.get_json()
ob = repo.OhlcRepo()
records = list(
ob.find_record_with_limit('quiz', {'domain': data['domain']}, 9))
results = {'beginner': [], 'intermediate': [], 'advanced': []}
for record in records:
record['_id'] = str(record['_id'])
if record['level'] == 1:
results['beginner'].append(record)
if record['level'] == 2:
results['intermediate'].append(record)
if record['level'] == 3:
results['advanced'].append(record)
return create_json(results)
def add_records():
data = request.get_json()
print(data)
print(type(data))
ob = repo.OhlcRepo()
ob.insert_record(collection_name="users",
query={'username': data['username']},
insert_doc={
'$set': {
'academics': data['academics'],
'courses': data['courses'],
'interests': data['interests']
}
})
return (jsonify({'data': 'success'}))
def find_top_courses():
#username = request.args.get('username')
domain = request.args.get('domain')
ob = repo.OhlcRepo()
final_list = []
for course_source in ['udemy', 'coursera', 'edx', 'youtube']:
records = list(
ob.find_record_with_limit('courses', {
'search_term': domain,
'course_source': course_source
}, 5))
for x in records:
x['_id'] = str(x['_id'])
final_list.append(x)
random.shuffle(final_list)
return create_json(final_list)
def check(username, otp):
#det=request.args
ob = repo.OhlcRepo()
res = ob.find_record_with_limit(collection_name="users",
query={"username": str(username)},
limit=1)[0]
print(res, "##")
if res['email_otp'] == otp:
ob.insert_record(collection_name="users",
query={"username": username},
insert_doc={"$set": {
"email_verified": True
}})
return (jsonify({'data': 'email verified successfuly', 'error': None}))
else:
return (jsonify({'data': None, 'error': 'Otp incorrect'}))
def getdetails():
un = request.args.get("username")
ob = repo.OhlcRepo()
res = ob.find_record_with_limit(collection_name="users",
query={"username": str(un)},
limit=1)[0]
print(res)
if 'academics' not in res.keys():
return (jsonify({'data': {'profile_incomplete': True}, 'error': None}))
else:
return (jsonify({
'data': {
'profile_incomplete': False
},
'error': None
}))
def search_by_domain():
username = request.args.get('username')
domain = request.args.get('domain')
ob = repo.OhlcRepo()
records = list(
ob.find_record_with_limit('users', {'username': username}, 1))
print(records)
if 'searched_keywords' in records[0]:
searched_keywords = records[0]['searched_keywords']
else:
searched_keywords = []
if domain not in searched_keywords:
searched_keywords.append(domain)
ob.update_query('users', {'username': username},
{'searched_keywords': searched_keywords})
return quiz(domain)
else:
return create_json('Run recommendation engine')
def store_quiz_result():
data = request.get_json()
username = data['username']
quiz_score = int(data['score'])
quiz_domain = data['domain']
if quiz_score < 6:
level = 1
elif quiz_score < 9:
level = 2
elif quiz_score == 9:
level = 3
ob = repo.OhlcRepo()
ob.insert_record('user_scores', {'username': username}, {
'$set': {
'score': int(quiz_score),
'level': level,
'domain': quiz_domain
}
})
return create_json('Run recommendation engine')
def authenticate():
username = request.args.get("username")
password = request.args.get("password")
dbObj = repo.OhlcRepo()
data = dbObj.find_record_with_limit("users", {"username": username}, 1)
if not data:
return (jsonify({'data': None, 'error': "Username Doesn't Exist"}))
else:
if username == data[0]["username"] and password == data[0]["password"]:
ret = {
'access_token':
create_access_token(identity=username,
expires_delta=datetime.timedelta(days=30)),
'refresh_token':
create_refresh_token(identity=username)
}
return jsonify(ret), 200
else:
return (jsonify({'data': None, 'error': "Username Doesn't Match"}))
def retres():
query = request.args.get("keyword")
un = request.args.get("username")
ob = repo.OhlcRepo()
res = ob.find_record_with_projection_limit(collection_name="users",
query={"usrname": un})
def group_by_current_role():
username = request.args.get('username')
domain = request.args.get('domain')
ob = repo.OhlcRepo()
user_record = list(
ob.find_record_with_limit('users', {'username': username}, 1))
user_record = user_record[0]
current_role = user_record['academics'][0]['role']
_id = str(user_record['_id'])
total_courses_done = len(user_record['courses'])
domain_course_count = 0
for course in user_record['courses']:
if course['domain'] == domain:
domain_course_count += 1
user_record['domain_inclination'] = round(
domain_course_count / total_courses_done * 10, 2)
records = list(
ob.find_records_with_query('users', {'current_role': current_role}))
community_records = [i for i in records if not (str(i['_id']) == _id)]
filtered_records = []
for another_user in community_records:
total_courses_done = len(another_user['courses'])
domain_course_count = 0
for course in user_record['courses']:
if course['domain'] == domain:
domain_course_count += 1
another_user['domain_inclination'] = round(
domain_course_count / total_courses_done * 10, 2)
another_user['inclination_diff'] = int(
abs(another_user['domain_inclination'] -
user_record['domain_inclination']))
fuzzy_result = {}
user_courses = []
for another_user in community_records:
count = 0
# Academic background
academic_meta = []
for degrees in another_user['academics']:
academic_meta.append(degrees['institute_name'] + " : " +
degrees['name'])
# Courses background
course_meta = []
for courses in another_user['courses']:
course_meta.append(courses['title'] + " : " + courses['domain'])
# Interests
interested_domain = another_user['interests']['domain']
interested_goal = another_user['interests']['goal']
# Compare with user_record
for degrees in user_record['academics']:
if str(degrees['institute_name'] + " : " +
degrees['name']) in academic_meta:
count += 1
for courses in user_record['courses']:
user_courses.append(
str(courses['title'] + " : " + courses['domain']))
if str(courses['title'] + " : " +
courses['domain']) in course_meta:
count += 1
if user_record['interests']['domain'] == interested_domain:
count += 1
if user_record['interests']['goal'] == interested_goal:
count += 1
another_user['similarity_count'] = count
# Continue with fuzzy logic
for another_user in community_records:
fuzzy_result[another_user['username']] = fuzzify(
10 - another_user['inclination_diff'],
another_user['similarity_count'] / 2)
return_list = []
for keyy, value in sorted(fuzzy_result.items(),
key=lambda item: item[1],
reverse=True):
print("%s: %s" % (keyy, value))
return_list.append({'username': keyy, 'fuzz_score': value})
missing_courses = []
for result in return_list:
records = list(
ob.find_record_with_limit('users',
{'username': result['username']}, 1))
for course in records[0]['courses']:
if course['title'] + " : " + course[
'platform'] not in user_courses and course[
'domain'] == domain:
temp = list(
ob.find_record_with_limit(
'courses', {
'course_title': course['title'],
'course_source': course['platform']
}, 1))
temp[0]['_id'] = str(temp[0]['_id'])
missing_courses.append(temp[0])
return create_json(missing_courses)