def get_candle_render_data(request, ticker, start_date):
# sample viz https://echarts.apache.org/examples/zh/editor.html?c=candlestick-brush
# returning data structure should be look like this:
# stock_data: {
# categoryData: ["2020-12-18", "2020-12-19", "2020-12-20", "2020-12-21", "2020-12-22"],
# values: [[3243.989990234375, 3201.64990234375, 3171.60009765625, 3249.419921875],
# [3200.010009765625, 3206.179931640625, 3166.0, 3226.969970703125],
# [3202.840087890625, 3206.52001953125, 3180.080078125, 3222.0],
# [3205.0, 3185.27001953125, 3184.169921875, 3210.1298828125],
# [3193.89990234375, 3172.68994140625, 3169.0, 3202.0]],
# volumes: [[0, 5995700, 1], [1, 3836800, 1], [2, 2369400, -1], [3, 2093800, 1], [4, 1451900, -1]],
# MA5: [3243, 3200, 3202, 3205, 3193],
# MA10: [3243, 3201, 3212, 3235, 3199],
# MA20: [3233, 3220, 3222, 3225, 3198],
# MA30: [3223, 3210, 3232, 3215, 3197],
# },
logger.info("parameter stock is: ----> ", ticker)
start_date_obj = datetime.strptime(start_date, '%Y-%m-%d')
metadata = StockMetaData(ticker, start_date_obj)
generator = StockDataGenerator(metadata)
data_obj = generator.download_and_wrap_basic_info()
if data_obj is not None:
return JsonResponseResult().ok(data=data_obj)
else:
return JsonResponseResult().error(code=405,
data="failed to download data of " +
ticker + ", please check trickier.")
def get_latest_index(request, ticker):
logger.info("parameter stock is: ----> ", ticker)
index_values = read_txt_file(ticker)
if index_values is not None:
return JsonResponseResult().ok(data=index_values)
else:
return JsonResponseResult().error(
code=405, data="failed to get latest index value of " + ticker)
def get_latest_news(request, ticker):
logger.info("parameter stock is: ----> ", ticker)
raw_news = crawl_news(ticker)
if len(raw_news) > 0:
scored_news = generate_score(raw_news, textKey="content")
return JsonResponseResult().ok(data=scored_news)
else:
return JsonResponseResult().error(
code=405, data="failed to get current news data of " + ticker)
def get_todays_emotion(request, ticker):
logger.info("parameter stock is: ----> ", ticker)
raw_news = crawl_news(ticker, size=20)
if len(raw_news) > 0:
scored_news = calculate_proportion(raw_news, textKey="content")
return JsonResponseResult().ok(data=scored_news)
else:
return JsonResponseResult().error(
code=405, data="failed to get current news data of " + ticker)
def get_basic_info(request, ticker, start_date):
logger.info("parameter stock is: ----> ", ticker)
start_date_obj = datetime.strptime(start_date, '%Y-%m-%d')
metadata = StockMetaData(ticker, start_date_obj)
generator = StockDataGenerator(metadata)
_, data_items = generator.download_basic_info()
if len(data_items) > 0:
return JsonResponseResult().ok(data=data_items)
else:
return JsonResponseResult().error(code=405,
data="failed to download data of " +
ticker + ", please check trickier.")
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 init_filter_option(request):
"""
this func return some data to render the filter when the page first load.
:param request:
:return:
"""
data = {
"areas": [
'New England', 'Mid East', 'Great Lakes', 'Plains', 'Southeast',
'Southwest', 'Rocky Mountains', 'Far West', 'Outlying areas'
],
"marjors": [
'Liberal Arts and Humanities', 'Kinesiology and Exercise',
'Business', 'Psychology', 'Marketing', 'Nursing',
'Sport and Fitness', 'Agriculture', 'Managerial', 'Biology',
'International Business', 'Healthcare', 'Social Science',
'Public Health', 'Mathematics', 'Creative',
'Criminal Justice and Safety', 'Radiation', 'Painting',
'Photography', 'Design and Visual', 'Biblical Studies', 'Finance',
'International', 'Accounting', 'Economics', 'Computer Science',
'English', 'Electrical Engineering', 'Mechanical Engineering',
'Chemical Engineering', 'Aerospace Engineering',
'Environmental Engineering', 'Criminal Justice and Safety Studies',
'Human Services', 'Sociology'
],
"tuitions": ['<= $5k', '<= $10k', '<= $15k']
}
return JsonResponseResult().ok(data=data)
def get_net_price(request, ticker, cost_price, amount):
url = "https://finance.api.seekingalpha.com/v2/real-time-prices?symbols={}".format(
ticker)
result_dict = send_get_request(url)
latestVal = result_dict['latestVal']
if latestVal != 0:
net_price = round(latestVal * amount, 3)
floating_price = round((latestVal - cost_price) * amount, 3)
result_dict["netPrice"] = net_price
result_dict["floatingPrice"] = floating_price
result_dict['percentChange'] = str(
100 * round(floating_price / (cost_price * amount), 3)) + '%'
return JsonResponseResult().ok(data=[result_dict])
else:
return JsonResponseResult().error(code=405,
data="failed to get net price of " +
ticker)
def predict_future_price(request, ticker, start_date="2018-01-01"):
logger.info("parameter stock is: ----> ", ticker)
start_date_obj = datetime.strptime(start_date, '%Y-%m-%d')
metadata = StockMetaData(ticker, start_date_obj)
generator = StockDataGenerator(metadata)
model = None
try:
model = StockModel(metadata)
model.load()
except FileNotFoundError:
return JsonResponseResult().error(
code=405,
data="failed to load model file of " + ticker +
", please check trickier.")
y_test = model.predict(generator)
result = generator.concat_prediction_result(y_test)
if len(result) > 0:
return JsonResponseResult().ok(data=result)
else:
return JsonResponseResult().error(
code=405, data="failed to predict future value of " + ticker)
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 index(request):
logger.info('this is a sample request')
data = {
"areas": [
'New England', 'Mid East', 'Great Lakes', 'Plains', 'Southeast',
'Southwest', 'Rocky Mountains', 'Far West', 'Outlying areas'
],
"nums": {
"odd": [1, 3, 5],
"even": [2, 4, 6]
},
"tuitions": ['<= $5k', '<= $10k', '<= $15k']
}
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 get_recommend_tags(request):
"""
:param request:
:param id: you will receive a school id (str) (required)
:return: you need to return a list of recommend tag, enabling people do quick search.
[{
'name': 'USC',
'type': 'primary', # primary | success | info | warning | danger
'link': ''},
},{},...]
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 'get_recommend_tags'")
data = [
{'name': 'Ivy League', 'type': 'primary', 'link': ''},
{'name': 'University of California', 'type': 'success', 'link': ''},
{'name': 'California State University', 'type': 'info', 'link': ''},
]
return JsonResponseResult().ok(data=data)
import re
from JsonResponseResult import JsonResponseResult
from Neo4jConnectionPool import ConnectionPool
import logging
logger = logging.getLogger('django')
"""
normally, u just initialize a JsonResponseResult obj and dot ok().
and send back to the data you queried
Api response will be like this:
{
"code": 200,
"msg": "OK",
"data": .... (list, dict, or other thing)
}
statue code is important,
if there is a mistake, no matter caused by user or server, you
also need to response a proper json, and tell front end, what happened.
about this situation, you can use JsonResponseResult().error(data=data)
{
"code": 404,
"msg": "ERROR",
"data": .... (list, dict, or null)
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)
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 bad_request(request):
logger.info('this is a sample request')
return JsonResponseResult().error(data="this is sample error")
def test(request):
logger.info('this is a sample request')
data = [1, 2, 3, 4, 5, 6, 7]
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_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 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 search_by_tag(request, tag="tag_str"):
"""
user clicked tag label.
:param tag:
: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_tag' func. tag -> " +
tag)
ivy_league = ['Brown University', 'Columbia University', 'Cornell University', 'Darthmouth College',\
'Harvard University', 'University of Pennsylvania', 'Princeton University', 'Yale University']
uc = ['University of California, Berkeley', 'University of California, Davis','University of California, Santa Cruz',\
'University of California, Santa Barbara','University of California, San Diego','University of California, Los Angeles',\
'University of California, Irvine','University of California, Merced', 'University of California, Riverside']
csu = ['California State University, Bakersfield', 'California State University, Fullerton','California State University, Northridge',\
'California State University, Long Beach','California State Polytechnic University, Ponoma',\
'California State University Channel Islands','California State University, Chico','California State University, Dominguez Hills',\
'California State University, East Bay','California State University, Fresno','California State University, Los Angeles',\
'California State University Maritime Academy','California State University, Monterey Bay',\
'California State University, San Bernardino','California State University, San Marcos','California State University, Stanislaus']
data_objs = []
if tag == 'Ivy League':
data_objs = tag_query(ivy_league)
if tag == 'University of California':
data_objs = tag_query(uc)
if tag == 'California State University':
data_objs = tag_query(csu)
data = []
for result in data_objs:
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 get_sentimental_tags(request, id=""):
global review_tags
logger.info("func 'get_sentimental_tags' get a param id -> " + id)
if not review_tags:
with open("./niche_reviews_result.json", 'r',
encoding='utf-8') as file:
review_tags = json.load(file)
default_data = {
"positive_info": {
"data": [{
"name": "helpful",
"value": 16
}, {
"name": "good",
"value": 15
}, {
"name": "nice",
"value": 11
}, {
"name": "great",
"value": 10
}, {
"name": "diverse",
"value": 8
}, {
"name": "easy",
"value": 8
}, {
"name": "amazing",
"value": 8
}, {
"name": "first year",
"value": 7
}, {
"name": "more",
"value": 6
}, {
"name": "great school",
"value": 6
}, {
"name": "able",
"value": 5
}, {
"name": "make sure",
"value": 5
}, {
"name": "convenient",
"value": 5
}, {
"name": "friendly",
"value": 5
}, {
"name": "most",
"value": 5
}, {
"name": "other",
"value": 4
}, {
"name": "great professor",
"value": 4
}, {
"name": "knowledgeable",
"value": 4
}, {
"name": "supportive",
"value": 4
}, {
"name": "affordable",
"value": 4
}, {
"name": "fun",
"value": 4
}, {
"name": "much",
"value": 4
}, {
"name": "feel safe",
"value": 4
}, {
"name": "sure",
"value": 3
}, {
"name": "online course",
"value": 3
}, {
"name": "first semester",
"value": 3
}, {
"name": "different",
"value": 3
}, {
"name": "diverse campus",
"value": 3
}, {
"name": "other university",
"value": 3
}, {
"name": "great opportunity",
"value": 3
}, {
"name": "passionate",
"value": 3
}, {
"name": "willing",
"value": 3
}, {
"name": "only thing",
"value": 3
}, {
"name": "overall",
"value": 3
}, {
"name": "great experience",
"value": 3
}, {
"name": "nervous",
"value": 3
}, {
"name": "beautiful campus",
"value": 3
}, {
"name": "welcoming",
"value": 3
}, {
"name": "good experience",
"value": 3
}, {
"name": "grateful",
"value": 2
}],
"people": {
"alum": "5.8%",
"other": "10.0%",
"senior": "16.7%",
"junior": "16.7%",
"sophomore": "25.0%",
"freshman": "25.8%"
},
"percent":
"50.0%",
"total":
"120"
},
"negative_info": {
"data": [{
"name": "expensive",
"value": 9
}, {
"name": "good",
"value": 6
}, {
"name": "terrible",
"value": 5
}, {
"name": "bad",
"value": 5
}, {
"name": "greek life",
"value": 4
}, {
"name": "financial aid",
"value": 4
}, {
"name": "great",
"value": 4
}, {
"name": "little",
"value": 4
}, {
"name": "okay",
"value": 4
}, {
"name": "good luck",
"value": 4
}, {
"name": "horrible",
"value": 3
}, {
"name": "boring",
"value": 3
}, {
"name": "social life",
"value": 3
}, {
"name": "bad part",
"value": 3
}, {
"name": "cold",
"value": 3
}, {
"name": "nice",
"value": 3
}, {
"name": "free",
"value": 3
}, {
"name": "fun",
"value": 3
}, {
"name": "amazing",
"value": 3
}, {
"name": "much",
"value": 3
}, {
"name": "many",
"value": 3
}, {
"name": "difficult",
"value": 3
}, {
"name": "available",
"value": 3
}, {
"name": "hard",
"value": 3
}, {
"name": "motivated",
"value": 2
}, {
"name": "helpful",
"value": 2
}, {
"name": "high",
"value": 2
}, {
"name": "willing",
"value": 2
}, {
"name": "many people",
"value": 2
}, {
"name": "convenient",
"value": 2
}, {
"name": "own fun",
"value": 2
}, {
"name": "next semester",
"value": 2
}, {
"name": "sunny",
"value": 2
}, {
"name": "many option",
"value": 2
}, {
"name": "low",
"value": 2
}, {
"name": "interesting",
"value": 2
}, {
"name": "right",
"value": 2
}, {
"name": "Most",
"value": 2
}, {
"name": "well",
"value": 2
}, {
"name": "few",
"value": 2
}],
"people": {
"other": "2.5%",
"alum": "10.0%",
"senior": "18.3%",
"junior": "20.0%",
"sophomore": "24.2%",
"freshman": "25.0%"
},
"percent":
"50.0%",
"total":
"120"
}
}
result = review_tags.get(id, default_data)
return JsonResponseResult().ok(data=result)
def get_similar_school_data(request, id='asdas31asdada'):
"""
:param request:
:param id: you will receive a school id (str) (required)
:return: you need to return a list of similar school of this school
[{
'id': 1,
'name': 'University Of Southern California1',
'similarity': '96%', 'link': '',
'rating': {
'Niche': 5,
'CC': 3
}
},{},...]
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_similar_school_data' get a param id -> " + id)
data = [{
'id': 1,
'name': 'University Of Southern California1',
'similarity': '96%',
'link': '',
'rating': {
'Niche': 5,
'CC': 3,
}
}, {
'id': 2,
'name': 'University Of Southern California2',
'similarity': '87%',
'link': '',
'rating': {
'Niche': 5,
'CC': 3,
}
}, {
'id': 3,
'name': 'University Of Southern California3',
'similarity': '86%',
'link': '',
'rating': {
'Niche': 5,
'CC': 3,
}
}, {
'id': 4,
'name': 'University Of Southern California4',
'similarity': '86%',
'link': '',
'rating': {
'Niche': 5,
'CC': 3,
}
}, {
'id': 5,
'name': 'University Of Southern California5',
'similarity': '76%',
'link': '',
'rating': {
'Niche': 5,
'CC': 3,
}
}, {
'id': 6,
'name': 'University Of Southern California6',
'similarity': '66%',
'link': '',
'rating': {
'Niche': 5,
'CC': 3,
}
}, {
'id': 7,
'name': 'University Of Southern California7',
'similarity': '66%',
'link': '',
'rating': {
'Niche': 5,
'CC': 3,
}
}]
return JsonResponseResult().ok(data=data)
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_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)