def get_article(request, date_time, count):
"""
获取文章列表
:param date_time: 起始时间戳
:param count: 从起始时间回溯的条目
"""
try:
date_time = int(date_time)
count = int(count)
if count > 10:
count = 10
if count <= 0:
count = 1
except:
return response(code=-1, msg='类型错误')
articles = Article.objects.filter(
send_time__lte=date_time).order_by('-send_time')
filter_articles = []
next_date_time = 0
for o_article in articles:
if o_article.send_time != next_date_time:
next_date_time = o_article.send_time
count -= 1
if count < 0:
break
filter_articles.append(get_packed_article(o_article))
return response(
body=dict(articles=filter_articles, next_date_time=next_date_time))
def get_article_analyse(request, article_id):
try:
o_article = Article.objects.get(article_id=article_id)
except:
return response(code=1, msg='错误的文章ID')
analyse_list = []
analyses = ArticleAnalyse.objects.filter(article=o_article)
for o_analyse in analyses:
analyse_list.append(
dict(
like_num=o_analyse.like_num,
comment_num=o_analyse.comment_num,
read_num=o_analyse.read_num,
reprint_num=o_analyse.reprint_num,
create_time=int(o_analyse.create_time.timestamp()),
))
analyse_list_share = []
analyses = ArticleAnalyseShare.objects.filter(article=o_article)
for o_analyse in analyses:
analyse_list_share.append(
dict(
share_num=o_analyse.share_num,
create_time=int(o_analyse.create_time.timestamp()),
))
return response(
body=dict(analyse=analyse_list, analyse_share=analyse_list_share))
def analyse(request):
interval = int(Config.objects.get(key='interval').value)
o_last = Config.objects.get(key='analyse-signal')
last_time = int(o_last.value)
crt_time = datetime.datetime.now()
if int(crt_time.timestamp()) - last_time < int(interval) * 60:
return response()
kw_groups = KeywordGroup.objects.filter(disable=False)
# keywords = Keyword.objects.filter(disable=False)
lasting = int(Config.objects.get(key='lasting').value)
lasting = datetime.timedelta(minutes=lasting)
begin_time = crt_time - lasting
newses = News.objects.filter(publish_time__gte=begin_time)
# print(len(newses), begin_time)
for o_group in kw_groups:
count = 0
web_list = []
keywords = Keyword.objects.filter(disable=False, group_id=o_group.pk)
for o_keyword in keywords:
kw = o_keyword.kw.upper()
for news in newses:
if news.title.upper().find(kw) != -1:
count += 1
if news.source not in web_list:
web_list.append(news.source)
if count >= o_group.count and len(web_list) >= o_group.web_count:
Log.create(o_group.group_name, count, len(web_list),
count*len(web_list)//(o_group.count*o_group.web_count))
o_last.value = str(int(crt_time.timestamp()))
o_last.save()
return response()
def check_login(request):
ret = wx_check_image_scanned()
if ret == 0:
return response(body=1, msg='还没人扫')
if wx_get_token():
return response(body=0, msg='登录成功')
else:
return response(body=2, msg='登录失败')
def grab_article_list(request):
"""
抓取最新文章并更新更新分享量
"""
ret = grab_article(7, 0)
if not ret:
return response(code=1, msg='抓取文章失败，请尝试重新登录')
ret = grab_article(7, 7)
if not ret:
return response(code=1, msg='抓取文章失败，请尝试重新登录')
ret = grab_share_num()
if not ret:
return response(code=2, msg='抓取最新分享数据失败')
return response()
def reply_to_trail(request):
trail_id = request.POST['trail_id']
metric = request.POST['metric']
# study_id = request.POST['study_id']
# # get study by id
# ret = Study.get_study_by_id(study_id)
# if ret.error is not Error.OK:
# return error_response(ret.error)
# o_study = ret.body
# if not isinstance(o_study, Study):
# return error_response(Error.STRANGE)
# get trail by id
ret = Trail.get_trail_by_id(trail_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_trail = ret.body
if not isinstance(o_trail, Trail):
return error_response(Error.STRANGE)
o_study = o_trail.r_study
metric_str = json.dumps(metric, ensure_ascii=False)
o_trail.set_metric(metric_str)
ret = select_and_run(o_study)
if ret.error is not Error.OK:
return error_response(ret.error)
return response(body=ret.body)
def create_study(request):
"""
client ask server to create a study for running
"""
config = request.POST['config']
algo_id = request.POST['algo_id']
c_ip = request.POST['client_ip']
c_port = request.POST['client_port']
ret = get_user_from_session(request)
if ret.error is not Error.OK:
return error_response(ret.error)
o_user = ret.body
if not isinstance(o_user, User):
return error_response(Error.STRANGE)
ret = Algorithm.get_algo_by_id(algo_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_algo = ret.body
if not isinstance(o_algo, Algorithm):
return error_response(Error.STRANGE)
ret = Study.create(o_user, o_algo, config, c_ip, c_port)
if ret.error is not Error.OK:
return error_response(ret.error)
o_study = ret.body
if not isinstance(o_study, Study):
return error_response(Error.STRANGE)
return response(body=o_study.to_dict())
def ask_for_trail(request):
trail = request.POST['trail']
study_id = request.POST['study_id']
print(trail, study_id)
# get study by id
ret = Study.get_study_by_id(study_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_study = ret.body
if not isinstance(o_study, Study):
return error_response(Error.STRANGE)
o_study.finish_epoch()
if o_study.status == Study.STATUS_FINISH:
return error_response(Error.FINISHED)
trail_str = json.dumps(trail, ensure_ascii=False)
ret = Trail.create(o_study, trail_str)
if ret.error is not Error.OK:
return error_response(ret.error)
o_trail = ret.body
if not isinstance(o_trail, Trail):
return error_response(Error.STRANGE)
ret = trail_client.run(o_study.client_ip, o_study.client_port, trail_str, o_trail.pk)
if ret.error is not Error.OK:
return error_response(ret.error)
return response(body=ret.body)
def pause_study(request):
study_id = request.POST['study_id']
ret = get_user_from_session(request)
if ret.error is not Error.OK:
return error_response(ret.error)
o_user = ret.body
if not isinstance(o_user, User):
return error_response(Error.STRANGE)
# get study from study_id
ret = Study.get_study_by_id(study_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_study = ret.body
if not isinstance(o_study, Study):
return error_response(Error.STRANGE)
# check study belongs to user
if not o_study.belong(o_user):
return error_response(Error.NO_RIGHT_MODIFY_STUDY)
if o_study.status not in [Study.STATUS_RUNNING]:
return error_response(Error.STUDY_IS_NOT_RUNNING)
o_study.status = Study.STATUS_PAUSED
o_study.save()
return response(body=o_study.to_dict())
def auto_search(request):
query = request.GET.get('q', None)
term = request.GET.get('term', None)
if not query or not term:
return error_response(Error.NO_SEARCH_PARAMETER)
qs = SearchQuerySet().models(Course)
results = qs.auto_query(query)
result_list = []
for result in results:
ret = Section.get_sections_by_course(result.object)
if ret.error is not Error.OK:
return error_response(ret.error)
if not ret.body:
continue
sections = ret.body
for section in sections:
if section.term == term:
result_list.append(result)
break
# result_list.append(result)
sorted_results = sorted(result_list, key=lambda x: x.score, reverse=True)
final_result = []
for result in sorted_results:
final_result.append(result.object.to_dict(term))
return response(body=final_result)
def get_meetings_by_section(request, course_id, section_id):
"""GET /api/courses/:course_id/sections/:section_id/meetings"""
ret = Course.get_course_by_id(course_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_course = ret.body
ret = Section.get_section_by_id(section_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_section = ret.body
ret = o_section.belong_to(o_course)
if ret.error is not Error.OK:
return error_response(ret.error)
ret = TimeSlot.get_meetings_by_section(o_section)
if ret.error is not Error.OK:
return error_response(ret.error)
meetings = ret.body
meeting_list = []
for meeting in meetings:
meeting_list.append(meeting.to_dict())
return response(body=meeting_list)
def get_algo_list(request):
ret = Algorithm.get_algo_list()
if ret.error is not Error.OK:
return error_response(ret.error)
algo_list = ret.body
return response(body=algo_list)
def get_terms(request):
"""GET /api/courses/terms"""
ret = Section.get_terms()
if ret.error is not Error.OK:
return error_response(ret.error)
terms = ret.body
return response(body=terms)
def group(request):
kws = Keyword.objects.all()
for kw in kws:
o_group = KeywordGroup.create(kw.kw, count=kw.count, web_count=kw.web_count)
kw.group_id = o_group.pk
kw.save()
return response()
def change_color_by_category(request):
course_id = request.POST['course_id']
category = request.POST['category']
color = request.POST['color']
bg_color = request.POST['bg_color']
term = request.POST['term']
ret = get_user_from_session(request)
if ret.error is not Error.OK:
return error_response(ret.error)
o_user = ret.body
ret = Course.get_course_by_id(course_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_course = ret.body
ret = SelectSection.get_selected_section_by_user(o_user)
if ret.error is not Error.OK:
return error_response(ret.error)
select_sections = ret.body
select_section_list = []
for select_section in select_sections:
if select_section.section.course == o_course and select_section.section.category == category and select_section.section.term == term:
select_section.bgcolor = bg_color
select_section.color = color
select_section.save()
select_section_list.append(select_section.to_dict())
return response(body=select_section_list)
def get_sibling_sections(request, course_id):
"""POST /api/courses/:course:id/sections"""
category = request.POST['category']
term = request.POST['term']
type = request.POST['type']
section_id = request.POST['section_id']
ret = Course.get_course_by_id(course_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_course = ret.body
ret = Section.get_sections_by_course(o_course)
if ret.error is not Error.OK:
return error_response(ret.error)
sections = ret.body
section_list = []
for section in sections:
if section.category == category and section.term == term and section.type == type and section.id != section_id:
section_list.append(dict(
sibling=section.to_dict(),
self_id=section_id,
))
return response(body=section_list)
def get_course_info(request, course_id):
"""GET /api/courses/:course_id"""
ret = Course.get_course_by_id(course_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_course = ret.body
return response(body=o_course.to_dict())
def delete_section_by_category(request):
"""DELETE /api/selectsections"""
course_id = request.POST['course_id']
category = request.POST['category']
term = request.POST['term']
ret = get_user_from_session(request)
if ret.error is not Error.OK:
return error_response(ret.error)
o_user = ret.body
ret = Course.get_course_by_id(course_id)
if ret.error is not Error.OK:
return error_response(ret.error)
o_course = ret.body
ret = SelectSection.get_selected_section_by_user(o_user)
if ret.error is not Error.OK:
return error_response(ret.error)
select_sections = ret.body
for select_section in select_sections:
if select_section.section.course == o_course and select_section.section.category == category and select_section.section.term == term:
select_section.delete()
return response()
def delete_event(request):
event_id = request.POST['event_id']
ret = Event.delete_event_by_id(event_id)
if ret.error is not Error.OK:
return error_response(ret.error)
return response()
def get_comment(request, article_id):
try:
o_article = Article.objects.get(article_id=article_id)
except:
return response(code=1, msg='错误的文章ID')
comments = Comment.objects.filter(comment_id=o_article.comment_id)
comment_list = []
for comment in comments:
comment_list.append(
dict(
nick_name=comment.nick_name,
post_time=comment.post_time,
content=comment.content,
icon=comment.icon,
))
return response(body=dict(comments=comment_list))
def add_keyword(request):
"""
添加关键字
"""
kw = request.POST['kw']
count = request.POST['count']
web_count = request.POST['web_count']
Keyword.create(kw, count, web_count)
return response()
def update_lasting(request):
"""
更新持续时长
"""
lasting = request.POST['lasting']
o = Config.objects.get(key='lasting')
o.value = lasting
o.save()
return response()
def update_interval(request):
"""
更新分析间隔
"""
interval = request.POST['interval']
o = Config.objects.get(key='interval')
o.value = interval
o.save()
return response()
def news_dealer(request):
"""
网站统一抓取
"""
crt_time = int(datetime.datetime.now().timestamp())
last_time = int(Config.objects.get(key=GLOBAL_SIGNAL).value)
if crt_time - last_time < int(Config.objects.get(key=GLOBAL_INTERVAL).value):
return response()
crt_time = datetime.datetime.now()
old_time = crt_time - datetime.timedelta(days=1)
# 抓取函数列表
funcs = [
qdaily_grab,
cnbeta_grab,
techweb_grab,
sspai_grab,
leiphone_grab,
dgtle_grab,
ithome_grab,
kr_grab,
ninetofivemac_grab,
ninetofivegoogle_grab,
solidot_grab,
chouti_grab,
TCEN_grab,
TCCN_grab,
sina_grab,
engadgetcn_grab,
engadgeten_grab,
applenewsroom_grab
]
for func in funcs:
ret = func() # 执行抓取
if ret is None:
continue
news_list, source = ret
for news in news_list: # 存储到数据库
if news['publish_time'] > old_time:
News.create(news, source)
Config.create(GLOBAL_SIGNAL, str(int(datetime.datetime.now().timestamp()))) # 更新上次抓取时间
return response()
def get_courses_by_term(request):
term = request.POST['term']
ret = Section.get_course_by_term(term)
if ret.error is not Error.OK:
return error_response(ret.error)
courses = ret.body
course_list = []
for course in courses:
course_list.append(course.to_dict())
return response(body=course_list)
def delete_old(request):
crt_time = datetime.datetime.now()
old_time = crt_time - datetime.timedelta(days=1)
newses = News.objects.filter(publish_time__lt=old_time)
for news in newses:
news.delete()
logs = Log.objects.filter(create_time__lt=old_time)
for log in logs:
log.delete()
return response()
def delete_keyword(request):
"""
删除关键字
"""
k_id = request.POST['id']
try:
o = Keyword.objects.get(pk=k_id)
except:
return error_response(Error.NOT_FOUND_KEYWORD)
o.delete()
return response()
def init(request):
"""
初始化网站数据
"""
Config.create(GLOBAL_SIGNAL, '0')
Config.create(GLOBAL_INTERVAL, '20')
Config.create('lasting', '10') # 默认新闻频率统计范围
Config.create('interval', '10') # 默认统计数据时间间隔
Config.create('analyse-signal', '0') # 默认统计数据时间
# Admin.create('cp', 'Chaping321')
return response()
def user_login(request):
"""POST /api/user/login"""
username = request.POST['username']
password = request.POST['password']
ret = User.authenticate(username, password)
if ret.error is not Error.OK:
return error_response(ret.error)
o_user = ret.body
save_user_to_session(request, o_user)
return response(body=o_user.to_dict())
def refresh_hot(request):
last_log_id = int(request.POST['last_log_id'])
last_news_id = int(request.POST['last_news_id'])
if last_log_id == -1:
logs = Log.objects.all()[:20]
else:
logs = Log.objects.filter(pk__gt=last_log_id)
log_list = []
latest_log_id = last_log_id
for log in logs:
log_list.append(dict(
kw=log.kw,
count=log.count,
web_count=log.web_count,
great=log.great,
tag=log.get_tag(),
))
if latest_log_id < log.pk:
latest_log_id = log.pk
if last_news_id == -1:
newses = News.objects.all()
else:
newses = News.objects.filter(pk__gt=last_news_id)
news_list = []
latest_news_id = last_news_id
kws = Keyword.objects.all()
for news in newses:
title = news.title.upper()
for kw in kws:
if title.find(kw.kw.upper()) != -1:
title = title.replace(kw.kw.upper(), '<p class="highlight">'+kw.kw.upper()+'</p>')
news_list.append(dict(
# publish_time=news.publish_time,
children=[dict
(
title=title,
url=news.get_web_url(),
source=news.get_source()
)
],
time=news.publish_time.strftime("%m-%d %H:%M")
))
if latest_news_id < news.pk:
latest_news_id = news.pk
return response(body=dict(
logs=log_list,
last_log_id=latest_log_id,
newses=news_list,
last_news_id=latest_news_id,
))
