def get_popular_major(request, id='asdas31asdada'):
"""
:param request:
:param id: you will receive a school id (str) (required)
:return: you need to return a list of popular majors of this school
10 tags will look good on the page.
[{
'name': "Computer Science"
},{},...]
and use JsonResponseResult().ok(data=data) return
if there is any exception raised,
use JsonResponseResult().error(data=[], msg="explain your error", code="500") return
"""
logger.info("func 'get_popular_major' get a param id -> " + id)
connection = ConnectionPool()
result = connection.executeQuery("\
match(n)-[]-(m {name: '" + id + "'})\
match(n)-[]-(c)\
return labels(c) as c, c.name\
")
detail = []
for item in result:
if item['c'][0] == "n_pop_majors_node":
detail.append(item['c.name'])
data = []
for major in detail:
data.append({'name': major})
return JsonResponseResult().ok(data=data)
def get_loc_data(request, id='asdas31asdada'):
"""
:param request:
:param id: you will receive a school id (str) (required)
:return: you need to return a list of historical ranking data of this school
{
"markers": [
{'label': 'School',
'color': 'blue',
'lat': '40.702147',
'lng': '-74.015794',
'size': 'normal'}
],
"center": "Los Angeles, CA"
}
and use JsonResponseResult().ok(data=data) return
if there is any exception raised,
use JsonResponseResult().error(data=[], msg="explain your error", code="500") return
"""
logger.info("func 'get_ranking_data' get a param id -> " + id)
connection = ConnectionPool()
result = connection.executeQuery("\
match(n)-[]-(m {name: '" + id + "'})\
match(n)-[]-(c)\
return labels(c) as c, c.name\
")
detail, data = {}, {}
for item in result:
if item['c'][0] == "addr_node":
detail['address'] = item.get('c.name', '')
if item['c'][0] == "city_node":
detail['city'] = item.get('c.name', '')
if item['c'][0] == "state_node":
detail['state'] = item.get('c.name', '')
center_str = detail['city'] + ", " + detail['state']
markers = []
if '' != detail['address']:
lag, lng = address2geo(detail['address'], center_str)
markers.append({
'label': 'School',
'color': 'orange',
'lat': lag,
'lng': lng,
'size': 'normal'
})
data['markers'] = markers
data['center'] = center_str
return JsonResponseResult().ok(data=data)
def testNeo4j(request):
"""
This func just tell you how to connect to neo4j and do the search
:param request:
:return:
"""
connection = ConnectionPool()
# result = connection.executeQuery(
# "MATCH (cloudAtlas2 {title: $param, tagline: $param1}) RETURN cloudAtlas2",
# param="Cloud Atlas",
# param1="Everything is connected")
result2 = connection.executeQuery(
"MATCH (tom:Person {name: \"Tom Hanks\"})-[:ACTED_IN]->(tomHanksMovies) RETURN tom,tomHanksMovies"
)
return JsonResponseResult().ok(data=result2)
def tag_query(tag_str):
connection = ConnectionPool()
data_objs = []
for school in tag_str:
result = connection.executeQuery("match (node_school {name: '" +
school + "'})\
match (node_school)-[:AVG_ACT]->(node_avg_act) \
match (node_school)-[r:HAS_QS_RANK]->(node_qs_rank) \
match (node_school)-[:HAS_TUITION_OF]->(node_tuition)\
match (node_school)-[:HAS_SAT_MAX_OF]->(node_sat_max)\
match (node_school)-[:HAS_SAT_MIN_OF]->(node_sat_min)\
match (node_school)-[:ID]->(node_id)\
match (node_school)-[:IS_TYPE]->(node_school_type)\
match (node_school)-[:IN_REGION]->(node_region)\
match (node_school)-[:HAS_LOGO]->(node_logo)\
match (node_school)-[:HAS_CC_SCORE]->(node_cc_score)\
match (node_school)-[:HAS_ADDRESS]->(node_address)\
match (node_school)-[:HAS_STATE]->(node_state)\
match (node_school)-[:HAS_CITY]->(node_city)\
match (node_school)-[:HAS_ZIP]->(node_zip)\
match (node_school)-[:HAS_WEBSITE]->(node_web)\
match (node_school)-[:IS_TYPE]->(node_type)\
match (node_school)-[:ACCEPT_RATE]->(node_accept_rate)\
match (node_school)-[:HAS_STUDENT_FACULTY_RATIO_OF]->(node_s_f_ratio)\
match (node_school)-[:HAS_SETTING]->(node_school_setting)\
match (node_school)-[:HAS_SIZE]->(node_size)\
match (node_school)-[:HAS_TELEPHONE]->(node_telephone)\
return node_id.name, node_school.name, node_logo.name,\
node_cc_score.name, node_address.name, node_state.name,\
node_city.name, node_zip.name, node_tuition.name, node_web.name,\
node_type.name, node_accept_rate.name, node_sat_max.name,\
node_sat_min.name, node_telephone.name, node_qs_rank.name, \
node_s_f_ratio.name,node_school_setting.name, node_size.name,\
node_avg_act.name LIMIT 90\
")
data_objs.append(result)
return data_objs
def index(request):
"""
this func is using to render the index page when user first clicked our app.
:param request: Nothing send here.
:return: no matter what happened you need to return a dict_list (element in list is dict)
[{
'id': '1', # -> school_id (str)
'name': 'University of AAAAAA', # -> school name (str)
'logo': 'school_logo.jpg', # -> school-name.jpg (str) e.g. university-of-southern-california.jpg
'desc': '', # -> school description (str)
'rating': {
'QS': 5, # -> QS score (float)
'CC': 3, # -> college confidential score (float)
},
'review': '3453', # -> # of review (str)
'detail': 'detail/1', # -> its detail link, just combine detail + "/" + school_id
'address': '1420 22nd W St, Los Angeles, CA, 90007',
'tuition': '$17,234', # -> tuition (str)
'school_type': 'Private School',# -> school type
'ACT': '1500-1570', # -> ACT score range
'acceptance_rate': '7.88%'
}, {}, ...]
and use JsonResponseResult().ok(data=data) return
if there is any exception raised,
use JsonResponseResult().error(data=[], msg="explain your error", code="500") return
"""
logger.info("revoked func 'index'")
connection = ConnectionPool()
result = connection.executeQuery(
"\
match (node_school)-[r:HAS_QS_RANK]->(node_qs_rank)\
where 1 <=toInteger(node_qs_rank.name) <= 15\
match (node_school)-[:AVG_ACT]->(node_avg_act)\
match (node_school)-[:HAS_SAT_MAX_OF]->(node_sat_max)\
where node_sat_max.name is not null\
match (node_school)-[:HAS_SAT_MIN_OF]->(node_sat_min)\
where node_sat_min.name is not null\
match (node_school)-[:HAS_TUITION_OF]->(node_tuition)\
match (node_school)-[:ID]->(node_id)\
match (node_school)-[:HAS_LOGO]->(node_logo)\
match (node_school)-[:HAS_WEBSITE]->(node_web)\
match (node_school)-[:HAS_CC_SCORE]->(node_cc_score)\
match (node_school)-[:HAS_ADDRESS]->(node_address)\
match (node_school)-[:HAS_STATE]->(node_state)\
match (node_school)-[:HAS_CITY]->(node_city)\
match (node_school)-[:HAS_ZIP]->(node_zip)\
match (node_school)-[:HAS_TUITION_OF]->(node_tuition)\
match (node_school)-[:IS_TYPE]->(node_type)\
match (node_school)-[:HAS_SIZE]->(node_size)\
match (node_school)-[:ACCEPT_RATE]->(node_accept_rate)\
match (node_school)-[:HAS_TELEPHONE]->(node_telephone)\
match (node_school)-[:AVG_GPA]->(node_gpa)\
match (node_school)-[:HAS_STUDENT_FACULTY_RATIO_OF]->(node_s_f_ratio)\
match (node_school)-[:HAS_SETTING]->(node_school_setting)\
return node_id.name, node_school.name, node_logo.name,\
node_cc_score.name, node_address.name, node_state.name,\
node_city.name, node_zip.name, node_tuition.name,\
node_type.name, node_accept_rate.name, node_sat_max.name,\
node_sat_min.name, node_telephone.name, node_avg_act.name,\
node_qs_rank.name, node_gpa.name, node_web.name, node_size.name,\
node_s_f_ratio.name,node_school_setting.name\
order by toInteger(node_qs_rank.name)\
limit 36\
")
data = []
for school in result:
obj = {
'id': school.get('node_id.name', ''),
'name': school.get('node_school.name', ''),
'logo': extract_logo_name(school['node_logo.name']),
'desc': school['node_school.name'] + " is a " + school.get('node_type.name', 'private')
+ " research university in " + school.get('node_city.name', 'somewhere')
+ ". And its campus located in " + school.get('node_school_setting.name', 'unknown') + " area. "
+ "And its campus size is " + school.get('node_size.name', 'unknown') + ". "
+ "And its student-faculty-ratio is " + school.get('node_s_f_ratio.name', 'unknown') + " . ",
'rating': {
'QS': format_qs_score(school.get('node_qs_rank.name', '')),
'CC': min(int(float(school['node_cc_score.name']) / 400) + 1, 5)
},
'detail': 'detail/' + school.get('node_id.name', ''),
'address': school.get('node_address.name', '') + ' ' +
school.get('node_city.name', '') + ', ' +
school.get('node_state.name', '') + ' ' +
school.get('node_zip.name', ''),
'tuition': '$' + str(int(float(school['node_tuition.name']))),
'school_type': school.get('node_type.name', '').capitalize(),
'ACT': school.get('node_sat_min.name', '') + '-' + school.get('node_sat_max.name', ''),
'acceptance_rate': str(round(float(school.get('node_accept_rate.name', '0')) * 100, 2)) + '%',
'link': school.get('node_web.name', ''),
'telephone': school.get('node_telephone.name', '')
}
data.append(obj)
return JsonResponseResult().ok(data=data)
def get_basic_info(request, id='2005'):
"""
this fun will be revoked when user click the detail page
:param request:
:param id: you will receive a school id (str) (required)
:return: you need to return an obj of basic info of this school
{
"title_info": {
'main_title': "",
'duration': "",
'school_type': "",
'location': "",
'school_link': ""
},
"desc_info": {
'title': "",
'location': "",
'avg_score': {
'reading': "",
'math': "",
'composite': ""
},
'expected_salary': "",
'cost': {
'net_price': "",
'national': "",
'financial_aid': "",
'avg_aid_award': ""
},
'admission': {
'acceptance_rate': "",
'application_ddl': ""
},
'students': {
'undergraduate': "",
'graduate': "",
'international': ""
}
}
}
and use JsonResponseResult().ok(data=data) return
if there is any exception raised,
use JsonResponseResult().error(data=[], msg="explain your error", code="500") return
"""
logger.info("func 'get_basic_info' get a param id -> " + id)
connection = ConnectionPool()
result = connection.executeQuery("\
match(n)-[]-(m {name: '" + id + "'})\
return n.name\
")
name = result[0]['n.name']
result = connection.executeQuery("\
match(n)-[]-(m {name: '" + id + "'})\
match(n)-[]-(c)\
return labels(c) as c, c.name\
")
detail = {}
for item in result:
if item['c'][0] == "school_type_node":
detail['setting'] = item['c.name'].capitalize()
if item['c'][0] == "web_node":
detail['website'] = item['c.name']
if item['c'][0] == "read_sat_node":
detail['read_sat'] = item['c.name']
if item['c'][0] == "math_sat_node":
detail['math_sat'] = item['c.name']
if item['c'][0] == "act_node":
detail['act'] = item['c.name']
if item['c'][0] == "addr_node":
detail['address'] = item['c.name']
if item['c'][0] == "city_node":
detail['city'] = item['c.name']
if item['c'][0] == "state_node":
detail['state'] = item['c.name']
if item['c'][0] == "zip_node":
detail['zip'] = item['c.name']
if item['c'][0] == "med_earn_6_years_node":
detail['med_earn'] = item['c.name']
if item['c'][0] == "tuition_node":
detail['tuition'] = item['c.name']
if item['c'][0] == "average_aid_node":
detail['avg_aid'] = item['c.name']
if item['c'][0] == "accept_rate_node":
if item['c.name'] != 'N/A':
detail['accept_rate'] = str(int(
float(item['c.name']) * 100)) + '%'
else:
detail['accept_rate'] = item['c.name']
if item['c'][0] == "app_dead_node":
detail['app_dead'] = item['c.name']
if item['c'][0] == "app_fee_node":
detail['app_fee'] = item['c.name']
if item['c'][0] == "undergrad_pop_node":
detail['undergrad_pop'] = item['c.name']
if item['c'][0] == "grad_pop_node":
detail['grad_pop'] = item['c.name']
if item['c'][0] == 'grad_rate_node':
detail['grad_rate'] = item['c.name']
if item['c'][0] == 'fresh_ret_node':
detail['fresh_ret_rate'] = item['c.name']
if item['c'][0] == 'emp_rate_node':
detail['emp_rate'] = item['c.name']
data = {
"title_info": {
'main_title': name,
'duration': '4-Years',
'school_type': detail.get('setting', '') + " University",
'location':
detail.get('city', '') + ', ' + detail.get('state', ''),
'school_link': detail.get('website', '')
},
"desc_info": {
'title':
name,
'location':
detail.get('address', '') + ' ' + detail.get('city', '') + ', ' +
detail.get('state', '') + ' ' + detail.get('zip', ''),
'avg_score': {
'reading': detail.get('read_sat', ''),
'math': detail.get('math_sat', ''),
'composite': detail.get('act', '')
},
'app_fee':
detail.get('app_fee', ''),
'expected_salary':
detail.get('med_earn', ''),
'cost': {
'net_price': detail.get('tuition', ''),
'avg_aid_award': detail.get('avg_aid', '')
},
'admission': {
'acceptance_rate': detail.get('accept_rate', ''),
'application_ddl': detail.get('app_dead', '')
},
'students': {
'undergraduate': detail.get('undergrad_pop', ''),
'graduate': detail.get('grad_pop', ''),
},
'stat': {
'graduation_rate': detail.get('grad_rate', ''),
'freshman_retention': detail.get('fresh_ret_rate', ''),
'employment_rate': detail.get('emp_rate', ''),
'median_salary': detail.get('med_earn', '')
}
}
}
return JsonResponseResult(data=data, code=200, msg='success')
def get_subject_info_data(request, id="asdasdasdsadas"):
"""
:param request:
:param id: you will receive a school id (str) (required)
:return: you need to return an obj of ACT SAT GPA data of this school
{
"niche_ranking": [
{'item': 'Academic', 'score': 4, 'label': 'A'},
{'item': 'Academic2', 'score': 4, 'label': 'A'},
{'item': 'Academic3', 'score': 4, 'label': 'A'},
{'item': 'Academic4', 'score': 4, 'label': 'A'},
{'item': 'Academic5', 'score': 4, 'label': 'A'},
],
"over_all_ranking": "A+",
"title_list": [
{'item': "National University", 'ranking': 24, 'desc': 'ssssssssssssssssssssssssssss'},
{'item': "Best College for Veterans", 'ranking': 8, 'desc': 'ssssssssssssssssssssssssssss'},
{'item': "Best Value Schools", 'ranking': 60, 'desc': 'ssssssssssssssssssssssssssss'},
{'item': "Top Performers on Social Mobility", 'ranking': 161, 'desc': 'ssssssssssssssssssssssssssss'},
]
}
and use JsonResponseResult().ok(data=data) return
if there is any exception raised,
use JsonResponseResult().error(data=[], msg="explain your error", code="500") return
"""
logger.info("func 'get_subject_info_data' get a param id -> " + id)
connection = ConnectionPool()
result = connection.executeQuery("match(node_school)-[:ID]->(n {name: '" +
id + "'})\
match(node_school)-[p:HAS_GRADE]->(node_n_grade)\
return node_school.name, node_n_grade.name, p.grade")
result2 = connection.executeQuery("match(node_school)-[:ID]->(n {name: '" +
id + "'})\
match(node_school)-[p:HAS_RANK]->(node_usn_rank)\
return node_school.name, node_usn_rank.name, p.rank")
grade = {'A+': 5.0, 'A': 5.0, 'A-': 4.7, 'B+': 4.3, 'B': 4.0, 'B-': 3.7, 'C+': 3.3, \
'C': 3.0, 'C-': 2.7, 'D+': 2.3, 'D': 2.0, 'D-': 1.7, 'F': 1.0, 'NG': 3.5}
inv_grade = {v: k for k, v in grade.items()}
niche = []
overall_grade = 0
for item in result:
overall_grade += grade.get(item.get('p.grade', ''), '')
if item.get('node_n_grade.name', '') in [
'Academics', 'Athletics', 'Student Life', 'Party Scene',
'Safety'
]:
niche.append({
'item': item.get('node_n_grade.name', ''),
'score': grade.get(item.get('p.grade', ''), ''),
'label': item.get('p.grade', '')
})
overall_grade /= 12
overall_rank = ""
overall_grade = round(overall_grade, 2)
for k, v in inv_grade.items():
if overall_grade >= k:
overall_rank = v
break
usn_rank = []
for item in result2:
usn_rank.append({
'item': item.get('node_usn_rank.name', ''),
'ranking': int(item.get('p.rank', '0'))
})
data = {
"niche_ranking": niche,
"over_all_ranking": overall_rank,
"title_list": usn_rank
}
return JsonResponseResult().ok(data=data)
def get_score_data(request, id="asdasdasdsadas"):
"""
:param request:
:param id: you will receive a school id (str) (required)
:return: you need to return an obj of ACT SAT GPA data of this school
{
"score_data": [
{'item': 'SAT_reading', 'niche': 67.5, 'cc': 60.3}, # div 10
{'item': 'SAT_writing', 'niche': 64.6, 'cc': 50.6}, # div 10
{'item': 'SAT_math', 'niche': 71.0, 'cc': 70.1}, # div 10
{'item': 'ACT', 'niche': 64, 'cc': 68}, # * 2
{'item': 'GPA', 'niche': 76, 'cc': 74} # * 20
],
"score_desc": {
'niche': {
'sat_range': '1390-1540',
'act_range': '32-35',
},
'cc': {
'sat': {
'reading': 731,
'writing': 656,
'math': 731,
},
'act': 32,
'gpa': 3.72
}
}
}
and use JsonResponseResult().ok(data=data) return
if there is any exception raised,
use JsonResponseResult().error(data=[], msg="explain your error", code="500") return
"""
logger.info("func 'get_score_data' get a param id -> " + id)
connection = ConnectionPool()
result = connection.executeQuery("\
match(n)-[]-(m {name: '" + id + "'})\
match(n)-[]-(c)\
return labels(c) as c, c.name\
")
detail = {}
for item in result:
if item['c'][0] == "read_sat_node":
if item['c.name'] != 'N/A':
detail['read_sat'] = item['c.name']
detail['read'] = item['c.name']
else:
detail['read_sat'] = '0'
detail['read'] = 'N/A'
if item['c'][0] == "math_sat_node":
if item['c.name'] != 'N/A':
detail['math_sat'] = item['c.name']
detail['math'] = item['c.name']
else:
detail['math_sat'] = '0'
detail['math'] = 'N/A'
if item['c'][0] == "write_sat_node":
if item['c.name'] != 'N/A':
detail['write_sat'] = item['c.name']
detail['write'] = item['c.name']
else:
detail['write_sat'] = '0'
detail['write'] = 'N/A'
if item['c'][0] == "act_node":
if item['c.name'] != 'N/A':
detail['act'] = item['c.name']
detail['ACT'] = item['c.name']
else:
detail['act'] = '0'
detail['ACT'] = 'N/A'
if item['c'][0] == "gpa_node":
if item['c.name'] != 'N/A':
detail['gpa'] = item['c.name']
detail['GPA'] = item['c.name']
else:
detail['gpa'] = '0'
detail['GPA'] = 'N/A'
data = {
"score_data": [
{
'item': 'SAT_reading',
'score': int(detail['read_sat']) / 10
}, # div 10
{
'item': 'SAT_writing',
'score': int(detail['write_sat']) / 10
}, # div 10
{
'item': 'SAT_math',
'score': int(detail['math_sat']) / 10
}, # div 10
{
'item': 'ACT',
'score': int(detail['act']) * 2
}, # * 2
{
'item': 'GPA',
'score': int(float(detail['gpa']) * 20)
} # * 20
],
"score_desc": {
'cc': {
'sat': {
'reading': detail.get('read', ''),
'writing': detail.get('write', ''),
'math': detail.get('math', ''),
},
'act': detail.get('ACT', ''),
'gpa': detail.get('GPA', '')
}
}
}
return JsonResponseResult().ok(data=data)
def get_fame_property(request, id="asdasda"):
logger.info("func 'get_fame_property' get a param id -> " + id)
connection = ConnectionPool()
result = connection.executeQuery("\
match(n)-[]-(m {name: '" + id + "'})\
match(n)-[]-(c)\
return labels(c) as c, c.name\
")
detail = {}
affil = []
athle = []
for item in result:
if item['c'][0] == "president_node":
detail['president'] = item['c.name']
if item['c'][0] == "motto_node":
detail['motto'] = item['c.name']
if item['c'][0] == 'affil_node':
affil.append({
'name':
item['c.name'],
'link':
"https://www.dbpedia.org/page/" +
'_'.join(item['c.name'].split())
})
if item['c'][0] == 'athletics_node':
athle.append({
'name':
item['c.name'],
'link':
"https://www.dbpedia.org/page/" +
'_'.join(item['c.name'].split())
})
if item['c'][0] == 'mascot_node':
detail['mascot'] = item['c.name']
if item['c'][0] == 'school_color_node':
detail['color'] = item['c.name']
import requests
from bs4 import BeautifulSoup
url = 'https://www.colorhexa.com/color.php'
colors = []
if detail['color'] != 'N/A':
col = [detail['color']]
for color in col:
item = color.replace('and', ',')
item = item.replace('&', ',')
item = item.replace(':', "")
item = list(map(lambda s: s.strip(), item.split(',')))
item = [i for i in item if i]
for color in item:
query_data = {'c': color, 'h': 'h'}
html = requests.post(url, query_data).text
soup = BeautifulSoup(html, 'html.parser')
rgb = soup.find('title').string.split()[2]
colors.append({'name': color, 'rgb': rgb})
data = {
"affiliations": affil,
"athletics": athle,
"president": {
"name":
detail.get('president', ''),
'profile':
"",
'link':
'https://www.dbpedia.org/page/' +
'_'.join(detail.get('president', 'N/A').split())
},
"motto": {
'words': detail.get('motto', ''),
'by': ""
},
"color": colors,
"mascot": {
'name': detail.get('mascot', ''),
'logo': "",
'link': ""
}
}
return JsonResponseResult(data=data, code=200, msg='success')
def search_by_major(request, major="major_str"):
"""
user clicked major label.
:param major: a str
:param request: Nothing send here.
:return: no matter what happened you need to return a dict_list (element in list is dict)
[{
'id': '1', # -> school_id (str)
'name': 'University of AAAAAA', # -> school name (str)
'logo': 'school_logo.jpg', # -> school-name.jpg (str) e.g. university-of-southern-california.jpg
'desc': '', # -> school description (str)
'rating': {
'QS': 5, # -> niche score (float)
'CC': 3, # -> college confidential score (float)
},
'review': '3453', # -> # of review (str)
'detail': 'detail/1', # -> its detail link, just combine detail + "/" + school_id
'address': '1420 22nd W St, Los Angeles, CA, 90007',
'tuition': '$17,234', # -> tuition (str)
'school_type': 'Private School',# -> school type
'ACT': '1500-1570', # -> ACT score range
'acceptance_rate': '7.88%'
}, {}, ...]
and use JsonResponseResult().ok(data=data) return
if there is any exception raised,
use JsonResponseResult().error(data=[], msg="explain your error", code="500") return
"""
logger.info(
"revoked func search/views.py 'search_by_major' func. major -> " +
major)
connection = ConnectionPool()
majors = "match (node_school)-[:HAS_N_POPULAR_MAJORS]->(node_popular_major {name: '" + major + "'}) "
result = connection.executeQuery(
"match (node_school)-[:AVG_ACT]->(node_avg_act) \
" + majors + "\
match (node_school)-[r:HAS_QS_RANK]->(node_qs_rank) \
match (node_school)-[:HAS_TUITION_OF]->(node_tuition)\
match (node_school)-[:HAS_SAT_MAX_OF]->(node_sat_max)\
match (node_school)-[:HAS_SAT_MIN_OF]->(node_sat_min)\
match (node_school)-[:ID]->(node_id)\
match (node_school)-[:IS_TYPE]->(node_school_type)\
match (node_school)-[:IN_REGION]->(node_region)\
match (node_school)-[:HAS_LOGO]->(node_logo)\
match (node_school)-[:HAS_CC_SCORE]->(node_cc_score)\
match (node_school)-[:HAS_ADDRESS]->(node_address)\
match (node_school)-[:HAS_STATE]->(node_state)\
match (node_school)-[:HAS_CITY]->(node_city)\
match (node_school)-[:HAS_ZIP]->(node_zip)\
match (node_school)-[:HAS_WEBSITE]->(node_web)\
match (node_school)-[:IS_TYPE]->(node_type)\
match (node_school)-[:ACCEPT_RATE]->(node_accept_rate)\
match (node_school)-[:HAS_STUDENT_FACULTY_RATIO_OF]->(node_s_f_ratio)\
match (node_school)-[:HAS_SETTING]->(node_school_setting)\
match (node_school)-[:HAS_SIZE]->(node_size)\
match (node_school)-[:HAS_TELEPHONE]->(node_telephone)\
return node_id.name, node_school.name, node_logo.name,\
node_cc_score.name, node_address.name, node_state.name,\
node_city.name, node_zip.name, node_tuition.name, node_web.name,\
node_type.name, node_accept_rate.name, node_sat_max.name,\
node_sat_min.name, node_telephone.name, node_qs_rank.name, \
node_s_f_ratio.name,node_school_setting.name, node_size.name,\
node_avg_act.name LIMIT 90\
")
data = []
for school in result:
if school['node_accept_rate.name'] != 'N/A':
school['node_accept_rate.name'] = str(
round(float(school['node_accept_rate.name']) * 100, 2)) + '%'
obj = {
'id':
school['node_id.name'],
'name':
school['node_school.name'],
'logo':
extract_logo_name(school['node_logo.name']),
'desc':
school['node_school.name'] + " is a " +
school.get('node_type.name', 'private') +
" research university in " +
school.get('node_city.name', 'somewhere') +
". And its campus located in " +
school.get('node_school_setting.name', 'unknown') + " area. " +
"And its campus size is " +
school.get('node_size.name', 'unknown') + ". " +
"And its student-faculty-ratio is " +
school.get('node_s_f_ratio.name', 'unknown') + " . ",
'rating': {
'QS': format_qs_score(school.get('node_qs_rank.name', '')),
'CC':
min(int(float(school['node_cc_score.name']) / 400) + 1, 5)
},
'detail':
'detail/' + school['node_id.name'],
'address':
school['node_address.name'] + ' ' + school['node_city.name'] +
' ' + school['node_state.name'] + ', ' + school['node_zip.name'],
'tuition':
'$' + school['node_tuition.name'],
'school_type':
school['node_type.name'].capitalize(),
'ACT':
school['node_sat_min.name'] + '-' + school['node_sat_max.name'],
'acceptance_rate':
school['node_accept_rate.name'],
'link':
school['node_web.name']
}
data.append(obj)
return JsonResponseResult().ok(data=data)
def index(request):
"""
this func only accept post request, which mean all the params wont show in the path (url)
:param request: all params saved here. there are:
content: the value in the input box
school_type: public | private | other
filter_content: this is an obj
if user did not use the filter, you will get a "{}"
or you will receive an obj like this
{
'area': 'New England',
'major': 'Music, theatre, or dance',
'tuition': '>= $5k',
'act': [28, 32],
'sat': [1500, 1600]
}
you can convert it into dict and do further process.
#TODO -> niche
when you use niche filter
you will receive this obj
{
"academic":4,
"dorms":3,
"food":2,
"location":1,
"safety":0,
"value":1
}
[0-4], all value will be int number
4 -> A+, A, A-,
3 -> B+, B, B-,
2 -> C+, C, C-,
1 -> D+, D, D-,
0 -> NG
:return:
"""
if request.method == "POST" and request.POST:
search_type = request.POST.get('search_type')
input_content = request.POST.get('content')
filter_content = request.POST.get('filter_content')
print("search_type -> ", search_type)
print("input_content -> ", input_content)
print("filter_content -> ", filter_content)
if "{}" == filter_content:
# user did not use filter
print("filert is null")
else:
# user used filter
selected_tags = json.loads(filter_content)
filter_content = eval(filter_content)
if 'academic' in filter_content:
universities = get_cluster_schools(filter_content)
connection = ConnectionPool()
data = []
for uni in universities:
result = connection.executeQuery("\
match (node_school {name: '" + uni.strip() + "'})\
match (node_school)-[:AVG_ACT]->(node_avg_act) \
match (node_school)-[:HAS_TUITION_OF]->(node_tuition)\
match (node_school)-[:HAS_SAT_MAX_OF]->(node_sat_max)\
match (node_school)-[:HAS_SAT_MIN_OF]->(node_sat_min)\
match (node_school)-[r:HAS_QS_RANK]->(node_qs_rank)\
match (node_school)-[:ID]->(node_id)\
match (node_school)-[:HAS_LOGO]->(node_logo)\
match (node_school)-[:HAS_CC_SCORE]->(node_cc_score)\
match (node_school)-[:HAS_ADDRESS]->(node_address)\
match (node_school)-[:HAS_STATE]->(node_state)\
match (node_school)-[:HAS_CITY]->(node_city)\
match (node_school)-[:HAS_ZIP]->(node_zip)\
match (node_school)-[:HAS_WEBSITE]->(node_web)\
match (node_school)-[:IS_TYPE]->(node_type)\
match (node_school)-[:ACCEPT_RATE]->(node_accept_rate)\
match (node_school)-[:HAS_TELEPHONE]->(node_telephone)\
match (node_school)-[:HAS_STUDENT_FACULTY_RATIO_OF]->(node_s_f_ratio)\
match (node_school)-[:HAS_SETTING]->(node_school_setting)\
match (node_school)-[:HAS_SIZE]->(node_size)\
return node_id.name, node_school.name, node_logo.name,\
node_cc_score.name, node_address.name, node_state.name,\
node_city.name, node_zip.name, node_tuition.name, node_web.name,\
node_type.name, node_accept_rate.name, node_sat_max.name,\
node_sat_min.name, node_telephone.name, node_qs_rank.name,\
node_s_f_ratio.name,node_school_setting.name, node_size.name,\
node_avg_act.name LIMIT 90\
")
for school in result:
if school['node_accept_rate.name'] != 'N/A':
school['node_accept_rate.name'] = str(
round(float(school['node_accept_rate.name']) * 100,
2)) + '%'
obj = {
'id':
school['node_id.name'],
'name':
school['node_school.name'],
'logo':
extract_logo_name(school['node_logo.name']),
'desc':
school['node_school.name'] + " is a " +
school.get('node_type.name', 'private') +
" research university in " +
school.get('node_city.name', 'somewhere') +
". And its campus located in " +
school.get('node_school_setting.name', 'unknown') +
" area. " + "And its campus size is " +
school.get('node_size.name', 'unknown') + ". " +
"And its student-faculty-ratio is " +
school.get('node_s_f_ratio.name', 'unknown') + " . ",
'rating': {
'QS':
format_qs_score(school.get('node_qs_rank.name', '')),
'CC':
min(
int(float(school['node_cc_score.name']) / 400) + 1,
5)
},
'detail':
'detail/' + school.get('node_id.name', ''),
'address':
school.get('node_address.name', '') + ' ' +
school.get('node_city.name', '') + ' ' +
school.get('node_state.name', '') + ', ' +
school.get('node_zip.name', ''),
'tuition':
'$' + school.get('node_tuition.name', ''),
'school_type':
school.get('node_type.name', '').capitalize(),
'ACT':
school.get('node_sat_min.name', '') + '-' +
school.get('node_sat_max.name', ''),
'acceptance_rate':
school.get('node_accept_rate.name', ''),
'link':
school.get('node_web.name', '')
}
data.append(obj)
print(obj)
return JsonResponseResult().ok(data=data)
connection = ConnectionPool()
if input_content != '':
uni = []
for item in input_content.split():
if len(item) > 3:
uni.append(item.capitalize())
else:
uni.append(item)
uni = ' '.join(uni)
result = connection.executeQuery("\
match (node_school {name: '" + uni + "'})\
match (node_school)-[:AVG_ACT]->(node_avg_act) \
match (node_school)-[:HAS_TUITION_OF]->(node_tuition)\
match (node_school)-[:HAS_SAT_MAX_OF]->(node_sat_max)\
match (node_school)-[:HAS_SAT_MIN_OF]->(node_sat_min)\
match (node_school)-[r:HAS_QS_RANK]->(node_qs_rank)\
match (node_school)-[:ID]->(node_id)\
match (node_school)-[:HAS_LOGO]->(node_logo)\
match (node_school)-[:HAS_CC_SCORE]->(node_cc_score)\
match (node_school)-[:HAS_ADDRESS]->(node_address)\
match (node_school)-[:HAS_STATE]->(node_state)\
match (node_school)-[:HAS_CITY]->(node_city)\
match (node_school)-[:HAS_ZIP]->(node_zip)\
match (node_school)-[:HAS_WEBSITE]->(node_web)\
match (node_school)-[:IS_TYPE]->(node_type)\
match (node_school)-[:ACCEPT_RATE]->(node_accept_rate)\
match (node_school)-[:HAS_TELEPHONE]->(node_telephone)\
match (node_school)-[:HAS_STUDENT_FACULTY_RATIO_OF]->(node_s_f_ratio)\
match (node_school)-[:HAS_SETTING]->(node_school_setting)\
match (node_school)-[:HAS_SIZE]->(node_size)\
return node_id.name, node_school.name, node_logo.name,\
node_cc_score.name, node_address.name, node_state.name,\
node_city.name, node_zip.name, node_tuition.name, node_web.name,\
node_type.name, node_accept_rate.name, node_sat_max.name,\
node_sat_min.name, node_telephone.name, node_qs_rank.name,\
node_s_f_ratio.name,node_school_setting.name, node_size.name,\
node_avg_act.name LIMIT 90\
")
data = []
for school in result:
if school['node_accept_rate.name'] != 'N/A':
school['node_accept_rate.name'] = str(
round(float(school['node_accept_rate.name']) * 100,
2)) + '%'
obj = {
'id':
school['node_id.name'],
'name':
school['node_school.name'],
'logo':
extract_logo_name(school['node_logo.name']),
'desc':
school['node_school.name'] + " is a " +
school.get('node_type.name', 'private') +
" research university in " +
school.get('node_city.name', 'somewhere') +
". And its campus located in " +
school.get('node_school_setting.name', 'unknown') + " area. " +
"And its campus size is " +
school.get('node_size.name', 'unknown') + ". " +
"And its student-faculty-ratio is " +
school.get('node_s_f_ratio.name', 'unknown') + " . ",
'rating': {
'QS':
format_qs_score(school.get('node_qs_rank.name', '')),
'CC':
min(int(float(school['node_cc_score.name']) / 400) + 1, 5)
},
'detail':
'detail/' + school.get('node_id.name', ''),
'address':
school.get('node_address.name', '') + ' ' +
school.get('node_city.name', '') + ' ' +
school.get('node_state.name', '') + ', ' +
school.get('node_zip.name', ''),
'tuition':
'$' + school.get('node_tuition.name', ''),
'school_type':
school.get('node_type.name', '').capitalize(),
'ACT':
school.get('node_sat_min.name', '') + '-' +
school.get('node_sat_max.name', ''),
'acceptance_rate':
school.get('node_accept_rate.name', ''),
'link':
school.get('node_web.name', '')
}
data.append(obj)
return JsonResponseResult().ok(data=data)
majors = area = act = s_type = sat_max = sat_min = tuition = ""
if 'major' in filter_content:
major = filter_content['major'].split(',')
if len(major[0]) != 0:
for item in major:
majors += "match (node_school)-[:HAS_N_POPULAR_MAJORS]->(node_popular_major {name: '" + str(
item) + "'}) "
else:
majors = " "
if search_type != '':
s_type = "match (node_school)-[:IS_TYPE]->(node_school_type {name:'" + search_type + "'})"
for key, value in filter_content.items():
if key == 'area' and value != '':
area = "match (node_school)-[:IN_REGION]->(node_region {name: '" + value + "'})" + " "
if key == 'act' and value != '':
act = "where " + str(
filter_content['act']
[0]) + " <= toInteger(node_avg_act.name) <= " + str(
filter_content['act'][1]) + " "
if key == 'sat' and value != '':
sat_max = "where " + str(
filter_content['sat']
[0]) + "<= toInteger(node_sat_max.name) <= " + str(
filter_content['sat'][1]) + " "
sat_min = "where " + str(
filter_content['sat']
[0]) + " <= toInteger(node_sat_min.name)<= " + str(
filter_content['sat'][1]) + " "
if key == 'tuition' and value != '':
tuition = "where toInteger(node_tuition.name) <= " + str(
int(''.join(
[i for i in filter_content['tuition'] if i.isdigit()])) *
1000) + " "
result = connection.executeQuery(
area + \
s_type + "\
match (node_school)-[:AVG_ACT]->(node_avg_act) " \
+ act + "\
match (node_school)-[:HAS_TUITION_OF]->(node_tuition) " + \
tuition + majors + "\
match (node_school)-[:HAS_SAT_MAX_OF]->(node_sat_max) " + \
sat_max + "\
match (node_school)-[:HAS_SAT_MIN_OF]->(node_sat_min) " + \
sat_min + "\
match (node_school)-[r:HAS_QS_RANK]->(node_qs_rank)\
match (node_school)-[:ID]->(node_id)\
match (node_school)-[:HAS_LOGO]->(node_logo)\
match (node_school)-[:HAS_CC_SCORE]->(node_cc_score)\
match (node_school)-[:HAS_ADDRESS]->(node_address)\
match (node_school)-[:HAS_STATE]->(node_state)\
match (node_school)-[:HAS_CITY]->(node_city)\
match (node_school)-[:HAS_ZIP]->(node_zip)\
match (node_school)-[:HAS_WEBSITE]->(node_web)\
match (node_school)-[:IS_TYPE]->(node_type)\
match (node_school)-[:ACCEPT_RATE]->(node_accept_rate)\
match (node_school)-[:HAS_TELEPHONE]->(node_telephone)\
match (node_school)-[:HAS_STUDENT_FACULTY_RATIO_OF]->(node_s_f_ratio)\
match (node_school)-[:HAS_SETTING]->(node_school_setting)\
match (node_school)-[:HAS_SIZE]->(node_size)\
return node_id.name, node_school.name, node_logo.name,\
node_cc_score.name, node_address.name, node_state.name,\
node_city.name, node_zip.name, node_tuition.name, node_web.name,\
node_type.name, node_accept_rate.name, node_sat_max.name,\
node_sat_min.name, node_telephone.name, node_qs_rank.name,\
node_s_f_ratio.name,node_school_setting.name, node_size.name,\
node_avg_act.name LIMIT 90\
" )
data = []
for school in result:
if school['node_accept_rate.name'] != 'N/A':
school['node_accept_rate.name'] = str(
round(float(school['node_accept_rate.name']) * 100, 2)) + '%'
obj = {
'id':
school['node_id.name'],
'name':
school['node_school.name'],
'logo':
extract_logo_name(school['node_logo.name']),
'desc':
school['node_school.name'] + " is a " +
school.get('node_type.name', 'private') +
" research university in " +
school.get('node_city.name', 'somewhere') +
". And its campus located in " +
school.get('node_school_setting.name', 'unknown') + " area. " +
"And its campus size is " +
school.get('node_size.name', 'unknown') + ". " +
"And its student-faculty-ratio is " +
school.get('node_s_f_ratio.name', 'unknown') + " . ",
'rating': {
'QS': format_qs_score(school.get('node_qs_rank.name', '')),
'CC':
min(int(float(school['node_cc_score.name']) / 400) + 1, 5)
},
'detail':
'detail/' + school.get('node_id.name', ''),
'address':
school.get('node_address.name', '') + ' ' +
school.get('node_city.name', '') + ' ' +
school.get('node_state.name', '') + ', ' +
school.get('node_zip.name', ''),
'tuition':
'$' + school.get('node_tuition.name', ''),
'school_type':
school.get('node_type.name', '').capitalize(),
'ACT':
school.get('node_sat_min.name', '') + '-' +
school.get('node_sat_max.name', ''),
'acceptance_rate':
school.get('node_accept_rate.name', ''),
'link':
school.get('node_web.name', '')
}
data.append(obj)
return JsonResponseResult().ok(data=data)