def toto_munhak_detail(munhak_seq):
data = {}
munhak_rows = cache.get("munhak_rows_data")
munhak_rows_data_dict = cache.get("munhak_rows_data_dict")
target_munhak_row = munhak_rows_data_dict.get(munhak_seq, None)
if target_munhak_row is None:
return abort(404)
data["munhak_row"] = target_munhak_row
title_same_rows = []
writer_same_rows = []
for munhak_row in munhak_rows:
if target_munhak_row["title"] == munhak_row["title"]:
title_same_rows.append(munhak_row)
elif target_munhak_row["writer"] != "작자 미상" and target_munhak_row[
"writer"] == munhak_row["writer"]:
writer_same_rows.append(munhak_row)
data["title_same_rows"] = list(reversed(title_same_rows))
data["writer_same_rows"] = list(reversed(writer_same_rows))
return jsonify(data)
def get_day_language_xp_list(self,
since: arrow.Arrow) -> List[DailyLanguageXp]:
cache_key = get_key_with_prefix(
f"{self.username}_{since.strftime('%Y-%m-%d')}", 'day_language_xp')
lock_key = get_key_with_prefix(cache_key, 'lock')
data = cache.get(cache_key)
# add lock to make sure only one request is fetching response from server (hopefully)
lock = cache.cache.inc(lock_key, delta=1)
set_redis_expire_seconds(lock_key, 15)
while data is None and isinstance(lock, int) and lock > 1:
time.sleep(1)
data = cache.get(cache_key)
lock = cache.get(lock_key)
if data is None:
post_data = '''{
profile(username: "******") {
day_language_xps: dayLanguageXps(since: "%s") {date language xp}
}
}''' % (self.username, since.strftime('%Y-%m-%d'))
response_json = requests.post(
'https://codestats.net/profile-graph', data=post_data).json()
current_app.logger.info('response json from %s: %s', self.username,
response_json)
data = response_json['data']['profile']['day_language_xps']
cache.set(cache_key, data, timeout=30 * 60)
current_app.logger.info('set cache [%s]', cache_key)
cache.delete(lock_key)
self.day_language_xp_list = DailyLanguageXpSchema().load(data,
many=True)
return self.day_language_xp_list
def add_pick():
user_seq = session["user"]["user_seq"]
args = request.form
pick_list_tmp = [args.get(f"pick{i}", "NaN") for i in range(1, 7)]
pick_list = []
for pick in pick_list_tmp:
if pick == "NaN":
pick_list.append(None)
else:
pick_list.append(int(pick))
print(args, pick_list)
# return
if len(pick_list) != 6:
return abort(400)
pick_list_not_none = [x for x in pick_list if x is not None]
if not len(pick_list_not_none) >= 2 and len(pick_list_not_none) <= 6:
print("@#@#$")
return abort(400)
if len(set(pick_list_not_none)) != len(pick_list_not_none):
return abort(400)
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
for pick in pick_list_not_none:
munhak_row = [
x for x in munhak_rows
if x["munhak_seq"] == pick and is_toto_target_munhak(x)
]
print(munhak_row, pick)
if len(munhak_row) == 0:
return abort(404)
old_pick_row = TotoPick.query.filter_by(user_seq=user_seq).first()
if old_pick_row is not None:
db.session.delete(old_pick_row)
pick_row = TotoPick(
user_seq=user_seq,
pick1=pick_list[0],
pick2=pick_list[1],
pick3=pick_list[2],
pick4=pick_list[3],
pick5=pick_list[4],
pick6=pick_list[5],
add_date=datetime.now(),
)
db.session.add(pick_row)
db.session.commit()
send_discord_alert_log(f"Pick add! {str(pick_list)}")
return "", 200
def start_live(data):
global room_info
# room_info = cache.get("room_info")
room_id = data["room_id"]
if room_id not in room_info or room_info[room_id]["room_master"] != request.sid or room_info[room_id][
"is_playing"] is not False:
emit("error")
for sid in room_info[room_id]["users"]:
if sid != request.sid and room_info[room_id]["users"][sid]["is_ready"] != True:
emit("alert_message", "모두 준비하지 않았습니다")
return
munhak_rows_data = cache.get("munhak_quiz_rows_data")
room_info[room_id]["is_playing"] = True
selected_quiz_list = []
quiz_data_list = []
munhak_rows = copy.deepcopy(munhak_rows_data)
for quiz_no in range(1, len(munhak_rows)):
not_selected_munhak_rows = [munhak_row for munhak_row in munhak_rows if
munhak_row["munhak_seq"] not in selected_quiz_list]
if not not_selected_munhak_rows:
break
quiz_data = make_quiz(munhak_rows, not_selected_munhak_rows)
quiz_data["quiz_no"] = quiz_no
selected_quiz_list.append(quiz_data["munhak_seq"])
quiz_data_list.append(quiz_data)
print(quiz_data_list)
room_info[room_id]["quiz_data_list"] = quiz_data_list
for sid in room_info[room_id]["users"]:
room_info[room_id]["users"][sid]["quiz_no"] = 1
room_info[room_id]["users"][sid]["correct"] = 0
room_info[room_id]["users"][sid]["wrong"] = 0
room_info[room_id]["users"][sid]["score"] = 0
game_code = uuid.uuid4()
room_info[room_id]["game_code"] = game_code
emit("live_started", {
"users": room_info[room_id]["users"],
"goal_score": room_info[room_id]["setting"]["goal_score"],
"correct_score": room_info[room_id]["setting"]["correct_score"],
"wrong_score": room_info[room_id]["setting"]["wrong_score"]
}, room=room_id)
import time
time.sleep(303)
if room_info[room_id]["game_code"] == game_code and room_info[room_id]["is_playing"] is True:
end_live(room_id)
def random_munhak():
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
random_munhak_row = random.choice(munhak_rows)
return redirect(url_for("board.munhak_board_detail", munhak_seq=random_munhak_row["munhak_seq"]))
def add_tip():
args = request.form
munhak_seq = args.get("munhak_seq", None)
content = args.get("content", None)
print(args)
if munhak_seq is None or not munhak_seq.isdigit() or content is None or type(content) != str:
return abort(400)
if not (1 <= len(content) <= 1000):
return abort(400)
munhak_seq = int(munhak_seq)
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
if len([munhak_row for munhak_row in munhak_rows if munhak_row["munhak_seq"] == munhak_seq]) == 0:
return abort(404)
# tag_name = re.sub("[^가-힣ㄱ-ㅎㅏ-ㅣa-zA-Z0-9]", "", tag_name)
user_seq = session["user"]["user_seq"]
old_tip_row = Tip.query.filter_by(user_seq=user_seq, munhak_seq=munhak_seq).first()
if old_tip_row is not None:
return abort(409)
tag_row = Tip(
tip_content=content,
user_seq=user_seq,
munhak_seq=munhak_seq,
add_date=datetime.now(),
)
db.session.add(tag_row)
db.session.commit()
return "", 200
def ratelimit_wrapper(*args, **kwargs):
ip_address = current_user.get_ip()
key = f"{key_prefix}:{ip_address}:{request.endpoint}"
current = cache.get(key)
if request.method == method:
if (current and int(current) > limit - 1):
return abort(429)
else:
if current is None:
cache.set(key, 1, timeout=interval)
else:
cache.set(key, int(current) + 1, timeout=interval)
return f(*args, **kwargs)
def pick_toto_form():
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows_data_dict = cache.get("munhak_rows_data_dict")
munhak_rows = copy.deepcopy(munhak_rows_data)
user_seq = session["user"]["user_seq"]
data = {}
munhak_group_data = defaultdict(list)
for munhak_row in munhak_rows:
if is_toto_target_munhak(munhak_row):
munhak_group_data[munhak_row["category"]].append(munhak_row)
data["munhak_group_data"] = munhak_group_data
old_pick_data = []
old_pick_row = TotoPick.query.filter_by(user_seq=user_seq).first()
if old_pick_row is not None:
for pick in [
old_pick_row.pick1, old_pick_row.pick2, old_pick_row.pick3,
old_pick_row.pick4, old_pick_row.pick5, old_pick_row.pick6
]:
if pick is not None:
old_pick_data.append(munhak_rows_data_dict[pick])
data["old_pick_data"] = old_pick_data
print(data)
r = make_response(render_template("./toto/toto_form.html", data=data))
r.set_cookie('PJAX-URL',
base64.b64encode(request.url.encode("UTF-8")),
max_age=None,
expires=None,
path='/')
return r
def set_real_username(self) -> None:
# use lowercase for cache key because it's case insensitive
username_lower = self.username.lower()
cache_key = get_key_with_prefix(username_lower, 'real_username')
real_username = cache.get(cache_key)
if real_username is None:
response = requests.get(
f'https://codestats.net/api/users/{self.username}')
if response.status_code == requests.codes.not_found:
raise UserNotFoundException()
real_username = response.json()['user']
current_app.logger.info('got real username %s for %s',
real_username, self.username)
cache.set(cache_key, real_username, timeout=24 * 60 * 60)
current_app.logger.info('set cache [%s]', cache_key)
# username in profile-graph api is case sensitive so set the username to the correct one
self.username = real_username
def index():
munhak_rows_data = cache.get("munhak_quiz_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
source_list = sorted(list(set([munhak_row["source"] for munhak_row in munhak_rows])))
source_dict = defaultdict(list)
for source in source_list:
source_dict[source[:5]].append(source)
data = {
"total_munhak": len(munhak_rows),
"source_list": sorted(set([munhak_row["source"] for munhak_row in munhak_rows])),
"source_dict" : source_dict
}
print(data)
session["quiz_count"] = 0
return render_template("quiz/index.html", data=data)
def write_tip_form(munhak_seq):
munhak_seq = munhak_seq
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
try:
munhak_row = [munhak_row for munhak_row in munhak_rows if munhak_row["munhak_seq"] == munhak_seq][0]
except:
return "", 404
data = {
"munhak_row": munhak_row
}
user_seq = session["user"]["user_seq"]
tip_row = Tip.query.filter_by(munhak_seq=munhak_seq, user_seq=user_seq).first()
if tip_row is not None:
data["content"] = tip_row.tip_content
return render_template("munhak_board_tip_form.html", data=data)
def write_reading_quiz_form(munhak_seq):
munhak_seq = munhak_seq
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
munhak_row = ContentQuizMunhak.query.filter_by(
munhak_seq=munhak_seq).first()
if munhak_row is None:
return abort(404)
data = {"munhak_row": munhak_row}
user_seq = session["user"]["user_seq"]
quiz_row = ContentQuiz.query.filter_by(munhak_seq=munhak_seq,
user_seq=user_seq).first()
if quiz_row is not None:
data["content"] = quiz_row.quiz_content
print(data["content"])
return render_template("reading_quiz_form.html", data=data)
def get_quiz():
# import time
# time.sleep(1)
if "exclude_quiz_source" not in session:
session["exclude_quiz_source"] = []
exclude_quiz_source = session["exclude_quiz_source"]
munhak_rows_data = copy.deepcopy(cache.get("munhak_quiz_rows_data"))
print(exclude_quiz_source)
# munhak_rows_data = []
def source_check(source):
if source in exclude_quiz_source:
return False
else:
return True
include_munhak_rows_data = [munhak_row for munhak_row in munhak_rows_data if source_check(munhak_row["source"])]
if "is_end" in session and session["is_end"] is True:
session["quiz_count"] = 0
session["total_munhak"] = len(include_munhak_rows_data)
session["solved_quiz"] = []
session["current_munhak"] = None
session["is_end"] = False
if "quiz_count" not in session:
session["quiz_count"] = 0
session["total_munhak"] = len(include_munhak_rows_data)
if "solved_quiz" not in session:
session["solved_quiz"] = []
session["result"] = None
quiz_no = session["quiz_count"] + 1
solved_quiz = session["solved_quiz"]
if "_id" not in session:
session["_id"] = uuid.uuid4()
if "current_munhak" not in session or session["current_munhak"] is None:
# munhak_rows = Munhak.query.filter_by(is_available=True).all()
include_munhak_rows = copy.deepcopy(include_munhak_rows_data)
all_munhak_rows = copy.deepcopy(munhak_rows_data)
not_solved_munhak_rows = [munhak_row for munhak_row in include_munhak_rows if
munhak_row["munhak_seq"] not in solved_quiz]
if len(not_solved_munhak_rows) == 0: # 다 맞았을 때
session["result"] = True
return "wow", 404
quiz_data = make_quiz(include_munhak_rows, not_solved_munhak_rows, all_munhak_rows=all_munhak_rows)
session["correct"] = simpleEnDecrypt.encrypt(f"{quiz_data['correct']}:{uuid.uuid4()}")
session["current_munhak"] = {
"munhak_seq": quiz_data["munhak_seq"],
"source": quiz_data["source"],
"category": quiz_data["category"],
"hint": quiz_data["hint"],
# "title": correct_munhak_row["title"],
# "writer": correct_munhak_row["writer"]
}
session["options"] = [munhak_row for munhak_row in quiz_data["option_munhak_rows"]]
data = {
"quiz_no": quiz_no,
"type": "객관식",
"category": quiz_data["category"],
"hint": quiz_data["hint"],
"options": quiz_data["options"],
"total_munhak": len(include_munhak_rows_data)
}
print(data)
#
return render_template("quiz/quiz.html", data=data)
else:
# print(hint)
data = {
"quiz_no": quiz_no,
"type": "객관식",
"category": session["current_munhak"]["category"],
"hint": session["current_munhak"]["hint"],
"options": [
f"{munhak_row['writer']}, 『{munhak_row['title']}』" for munhak_row in session["options"]
],
"total_munhak": len(include_munhak_rows_data)
}
print(data)
#
return render_template("quiz/quiz.html", data=data)
def add_video():
from urllib import parse
args = request.form
munhak_seq = args.get("munhak_seq", None)
munhak_source = args.get("munhak_source", None)
video_url = args.get("video_url", None)
type = args.get("type", None)
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
print(munhak_rows)
print(munhak_seq)
print(munhak_source)
if type == "munhak":
munhak_seq = int(munhak_seq)
if len([munhak_row for munhak_row in munhak_rows if munhak_row["munhak_seq"] == munhak_seq]) == 0:
return abort(404)
elif type == "exam":
if len([munhak_row for munhak_row in munhak_rows if munhak_row["source"] == munhak_source]) == 0:
return abort(404)
else:
return abort(404)
parts = parse.urlparse(video_url)
query = parse.parse_qs(parts.query)
print(query)
video_code = ""
start_time = "0"
try:
if "v" in query:
video_code = query["v"][0]
if "t" in query:
start_time = query["t"][0]
else:
start_time = "0"
else:
if parts.netloc == "youtu.be":
video_code = parts.path[1:]
if "t" in query:
start_time = query["t"][0]
else:
start_time = "0"
if not start_time.isdigit():
return abort(400)
video_url = f"https://youtu.be/{video_code}?t={start_time}"
print(video_url)
res = requests.get("https://www.googleapis.com/youtube/v3/videos", params={
"key": YOUTUBE_KEY, "part": "snippet", "id": video_code
})
print(res.text)
video = json.loads(res.text)["items"][0]
except:
return abort(400)
user_seq = session["user"]["user_seq"]
video_title = video["snippet"]["title"].replace("'", "'")
video_thumbnail = None
if "standard" in video["snippet"]["thumbnails"]:
video_thumbnail = video["snippet"]["thumbnails"]["standard"]["url"]
elif "high" in video["snippet"]["thumbnails"]:
video_thumbnail = video["snippet"]["thumbnails"]["high"]["url"]
elif "medium" in video["snippet"]["thumbnails"]:
video_thumbnail = video["snippet"]["thumbnails"]["medium"]["url"]
elif "default" in video["snippet"]["thumbnails"]:
video_thumbnail = video["snippet"]["thumbnails"]["default"]["url"]
if video_thumbnail is None:
return abort(404)
if type == "munhak":
old_video_row = Video.query.filter_by(munhak_seq=munhak_seq, youtube_code=video_code).first()
if old_video_row is not None:
return abort(409)
video_row = Video(user_seq=user_seq, munhak_seq=munhak_seq, youtube_url=video_url, youtube_title=video_title,
youtube_thumbnail=video_thumbnail, add_date=datetime.now(), youtube_code=video_code)
db.session.add(video_row)
db.session.commit()
else:
old_video_row = Video.query.filter_by(munhak_source=munhak_source, youtube_code=video_code).first()
if old_video_row is not None:
return abort(409)
video_row = Video(user_seq=user_seq, munhak_source=munhak_source, youtube_url=video_url,
youtube_title=video_title,
youtube_thumbnail=video_thumbnail, add_date=datetime.now(), youtube_code=video_code)
db.session.add(video_row)
db.session.commit()
return "", 200
def munhak_board_detail(munhak_seq, munhak_title):
# import time
# time.sleep(2)
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
target_munhak_row = None
for munhak_row in munhak_rows:
if munhak_row["munhak_seq"] == munhak_seq:
target_munhak_row = munhak_row
if target_munhak_row is None:
return render_template("munhak_board_detail_404.html")
if munhak_title != format_url_title(target_munhak_row["title"]):
return redirect(url_for('board.munhak_board_detail', munhak_seq=munhak_seq,
munhak_title=format_url_title(target_munhak_row["title"])))
if "user" in session:
user_seq = session["user"]["user_seq"]
else:
user_seq = -1
munhak_video_rows = Video.query.filter_by(munhak_seq=target_munhak_row["munhak_seq"]).all()
exam_video_rows = Video.query.filter_by(munhak_source=target_munhak_row["source"]).all()
munhak_video_list = [
dict(video_row.as_dict(), **{"is_mine": "true" if video_row.user_seq == user_seq else "false"}) for video_row
in munhak_video_rows]
exam_video_list = [
dict(video_row.as_dict(), **{"is_mine": "true" if video_row.user_seq == user_seq else "false"}) for video_row
in exam_video_rows]
tag_rows = db.session.query(Tag, func.count(Like.like_seq).label("like_count"),
func.count(Like.like_seq).filter(Like.user_seq == user_seq).label("liked")
).outerjoin(
Like,
Tag.tag_seq == Like.tag_seq).filter(Tag.munhak_seq == munhak_seq).group_by(Tag.tag_seq).order_by(
desc("like_count")).all()
tip_rows = db.session.query(Tip, func.count(Like.like_seq).label("like_count"),
func.count(Like.like_seq).filter(Like.user_seq == user_seq).label("liked")
).outerjoin(
Like,
Tip.tip_seq == Like.tip_seq).filter(Tip.munhak_seq == munhak_seq).group_by(Tip.tip_seq).order_by(
desc("like_count")).all()
# return "DD"
tips = [dict(tip_row.Tip.as_dict(),
**{"like_count": tip_row.like_count, "liked": "true" if tip_row.liked == 1 else "false",
"is_mine": "true" if tip_row.Tip.user_seq == user_seq else "false",
"user_nickname": tip_row.Tip.user.nickname}, ) for
tip_row in tip_rows]
tip_mine_exist = False
for tip in tips:
tip_mine_exist = tip_mine_exist or (tip["is_mine"] == "true")
try:
subject_last_word = target_munhak_row["subject"].split()[-1]
except:
subject_last_word = "N"
print(subject_last_word)
related_list = [munhak_row for munhak_row in munhak_rows
if (
munhak_row["title"] in target_munhak_row["title"] or
(target_munhak_row["writer"] != "작자 미상" and
munhak_row["writer"] == target_munhak_row["writer"]) or
target_munhak_row["title"] in munhak_row["title"]
) and (munhak_row["munhak_seq"] != target_munhak_row["munhak_seq"])]
related_list_subject = [munhak_row for munhak_row in munhak_rows if
(subject_last_word in munhak_row["subject"].split(" ")) and (
munhak_row["munhak_seq"] != target_munhak_row[
"munhak_seq"]) and munhak_row not in related_list]
random.shuffle(related_list_subject)
related_list_subject = related_list_subject[:min(5, len(related_list_subject))]
# related_list = list(related_list)
print(related_list)
data = {
"munhak_seq": munhak_seq,
"title": target_munhak_row["title"],
"writer": target_munhak_row["writer"],
"source": target_munhak_row["source"],
"category": target_munhak_row["category"],
"munhak_video_list": munhak_video_list,
"exam_video_list": exam_video_list,
"subject": target_munhak_row["subject"],
"tags": [dict(tag_row.Tag.as_dict(),
**{"like_count": tag_row.like_count, "liked": "true" if tag_row.liked == 1 else "false",
"is_mine": "true" if tag_row.Tag.user_seq == user_seq else "false"}) for
tag_row in tag_rows],
"tips": tips,
"tip_mine_exist": tip_mine_exist,
"related_list": related_list,
"related_list_subject": related_list_subject
}
print(request.url)
r = make_response(render_template("munhak_board_detail.html", data=data))
r.set_cookie('PJAX-URL', base64.b64encode(request.url.encode("UTF-8")), max_age=None, expires=None, path='/')
return r
def munhak_board_list():
cookies = request.cookies
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
args = request.args
query = args.get("query", None)
tag = args.get("tag", None)
category = args.get("category", None)
source = args.get("source", None)
clear = args.get("clear", None)
if "query" not in cookies:
clear = True
query_cookie = ""
if query is not None:
query_cookie += query + " "
source_list = sorted(list(set([munhak_row["source"] for munhak_row in munhak_rows])))
if clear is not None:
if category is not None:
query_cookie += " $" + category + " "
else:
query_cookie += "".join([" $" + x + " " for x in ["고전시가", "현대시", "고전산문", "현대소설", "극", "수필"]])
if source is not None:
query_cookie += " @" + source + " "
else:
query_cookie += "".join([" @" + x.replace(" ", "-") + " " for x in source_list])
if tag is not None:
query_cookie += " #" + tag + " "
print(query_cookie)
resp = make_response(redirect(url_for("board.munhak_board_list")))
resp.set_cookie('query', base64.b64encode(query_cookie.encode("UTF-8")))
resp.set_cookie("page", "1")
return resp
# print(query, tags)
try:
page = int(request.cookies.get("page", 1))
except:
page = 1
print(page * 10000000)
page_size = 10
source_dict = defaultdict(list)
for source in source_list:
source_dict[source[:5]].append(source)
data = {
"source_dict": source_dict
}
resp = make_response(render_template("munhak_board_list.html", data=data))
# resp.set_cookie('query', base64.b64encode(query_cookie.encode("UTF-8")))
resp.set_cookie("page", str(page))
resp.set_cookie('PJAX-URL', base64.b64encode(request.url.encode("UTF-8")), max_age=None, expires=None, path='/')
return resp
def munhak_board_render_card():
munhak_rows_data = cache.get("munhak_rows_data")
munhak_rows = copy.deepcopy(munhak_rows_data)
args = request.args
query = args.get("q", "")
# tags = args.get("tags", None)
query_list = query.split()
origin_query_list = copy.deepcopy(query_list)
try:
page = int(args.get("page", 1))
except:
page = 1
page_size = 10
# query_list.remove("#")
print(query)
print(query_list)
query_source_list = [word[1:].replace("-", " ") for word in query_list if word[0] == "@"]
print("qsl", query_source_list)
query_category_list = [word[1:] for word in query_list if word[0] == "$"]
print("qcl", query_category_list)
query_list = [word for word in query_list if word[0] != "@" and word[0] != "$"]
if len(query_list) != 0:
query_munhak_seq_set = set()
for word in query_list:
if word[0] != "#":
for munhak_row in munhak_rows:
if word in munhak_row["title"].replace(" ", "") or word == munhak_row["writer"]:
query_munhak_seq_set.add(munhak_row["munhak_seq"])
print(Tag.query.filter(
Tag.tag_name.in_([word[1:] for word in query_list if word[0] == "#"])).all())
tag_rows = Tag.query.filter(
Tag.tag_name.in_([word[1:] for word in query_list if word[0] == "#"])).all()
for tag_row in tag_rows:
query_munhak_seq_set.add(tag_row.munhak_seq)
# query_munhak_seq_set.add()
print(query_munhak_seq_set)
query_munhak_rows = [
[munhak_row for munhak_row in munhak_rows if munhak_seq == munhak_row["munhak_seq"]][0] for munhak_seq in
query_munhak_seq_set]
print(query_munhak_rows)
else:
query_munhak_rows = munhak_rows
query_munhak_rows = [
munhak_row for munhak_row in query_munhak_rows if munhak_row["source"] in query_source_list and munhak_row[
"category"] in query_category_list]
query_munhak_rows = sorted(query_munhak_rows, key=lambda x: (x["source"][:5], x["source"]), reverse=True)
data = {
"page": page,
"max_page": (len(query_munhak_rows) - 1) // page_size + 1,
"query": query,
"munhak_rows": [
{
"munhak_seq": munhak_row["munhak_seq"],
"title": munhak_row["title"],
"writer": munhak_row["writer"],
"source": munhak_row["source"],
"category": munhak_row["category"],
"tags": [tag_row.tag_name for tag_row in
db.session.query(Tag)
.outerjoin(Like, Tag.tag_seq == Like.tag_seq)
.filter(Tag.munhak_seq == munhak_row["munhak_seq"])
.group_by(Tag.tag_seq)
.order_by(desc(func.count(Like.like_seq).label("like_count")))
.all()
][:5],
} for munhak_row in query_munhak_rows[(page - 1) * page_size: page * page_size]
],
"search_query_tags": [word[1:] for word in query_list if word[0] == "#"],
"total_rows": len(query_munhak_rows)
}
print([word[1:] for word in query_list if word[0] == "#"])
resp = make_response(render_template("munhak_board_card.html", data=data))
query_cookie = " ".join(origin_query_list)
resp.set_cookie('query', base64.b64encode(query_cookie.encode("UTF-8")))
# print( )
return resp
def toto_index():
munhak_rows_data_dict = cache.get("munhak_rows_data_dict")
pick_deadline = datetime(2021, 11, 16, 23, 59, 59)
toto_real_result = [120, 122, 124, 126, 128, 130]
is_result_open = False
data = {}
data["is_result_open"] = is_result_open
try:
user_seq = session["user"]["user_seq"]
except:
user_seq = None
data["user_seq"] = user_seq
print(data)
if datetime.now() < pick_deadline:
# 픽 가능
data["is_pick_available"] = True
pick_rows = TotoPick.query.all()
pick_list = [{
"nickname": x.user.nickname,
"pick1": munhak_rows_data_dict.get(x.pick1),
"pick2": munhak_rows_data_dict.get(x.pick2),
"pick3": munhak_rows_data_dict.get(x.pick3),
"pick4": munhak_rows_data_dict.get(x.pick4),
"pick5": munhak_rows_data_dict.get(x.pick5),
"pick6": munhak_rows_data_dict.get(x.pick6),
"date": x.add_date.strftime("%Y-%m-%d"),
"user_seq": x.user.user_seq
} for x in pick_rows]
print(pick_list)
random.shuffle(pick_list)
data["pick_list"] = pick_list
resp = make_response(render_template("toto/index.html", data=data))
resp.set_cookie('PJAX-URL',
base64.b64encode(request.url.encode("UTF-8")),
max_age=None,
expires=None,
path='/')
return resp
else:
# 픽 종료
data["is_pick_available"] = False
if is_result_open:
pass
else:
pick_rows = TotoPick.query.all()
pick_list = [{
"nickname": x.user.nickname,
"pick1": munhak_rows_data_dict.get(x.pick1),
"pick2": munhak_rows_data_dict.get(x.pick2),
"pick3": munhak_rows_data_dict.get(x.pick3),
"pick4": munhak_rows_data_dict.get(x.pick4),
"pick5": munhak_rows_data_dict.get(x.pick5),
"pick6": munhak_rows_data_dict.get(x.pick6),
"date": x.add_date.strftime("%Y-%m-%d"),
"user_seq": x.user.user_seq
} for x in pick_rows]
random.shuffle(pick_list)
data["pick_list"] = pick_list
resp = make_response(render_template("toto/index.html", data=data))
resp.set_cookie('PJAX-URL',
base64.b64encode(request.url.encode("UTF-8")),
max_age=None,
expires=None,
path='/')
return resp
def get_quiz():
# import time
# time.sleep(1)
# time.sleep(1)
if "quiz_source" not in session:
session["quiz_source"] = "all"
else:
quiz_source = session["quiz_source"]
quiz_rows_data = cache.get("quiz_data")
# if quiz_source == "s1":
# munhak_rows_data = [munhak_row for munhak_row in munhak_rows_data if
# munhak_row["source"].split()[-1] != "수능특강" and munhak_row["source"].split()[-1] != "수능완성"]
# elif quiz_source == "s2":
# munhak_rows_data = [munhak_row for munhak_row in munhak_rows_data if
# munhak_row["source"].split()[-1] == "수능특강" or munhak_row["source"].split()[-1] == "수능완성"]
#
# if "is_end" in session and session["is_end"] is True:
# session["quiz_count"] = 0
# session["total_munhak"] = len(munhak_rows_data)
# session["solved_quiz"] = []
# session["current_munhak"] = None
# session["is_end"] = False
#
# if "quiz_count" not in session:
# session["quiz_count"] = 0
# session["total_munhak"] = len(munhak_rows_data)
if "solved_quiz" not in session:
session["solved_quiz"] = []
# session["result"] = None
#
# quiz_no = session["quiz_count"] + 1
solved_quiz = session["solved_quiz"]
#
# if "_id" not in session:
# session["_id"] = uuid.uuid4()
if "current_quiz" not in session or session["current_quiz"] is None:
# munhak_rows = Munhak.query.filter_by(is_available=True).all()
quiz_rows = copy.deepcopy(quiz_rows_data)
not_solved_quiz_rows = [quiz_row for quiz_row in quiz_rows if
quiz_row["quiz_seq"] not in solved_quiz]
if len(not_solved_quiz_rows) == 0: # 다 맞았을 때
session["solved_quiz"] = []
not_solved_quiz_rows = quiz_rows
quiz_data = make_quiz(quiz_rows, not_solved_quiz_rows)
session["current_quiz"] = quiz_data
if quiz_data["type"] == "choose":
data = {
"wrong_sentence": quiz_data["wrong_sentence"],
"type": quiz_data["type"]
}
elif quiz_data["type"] == "option":
data = {
"problem_sentence": quiz_data["problem_sentence"],
"key_list": quiz_data["key_list"],
"type" : quiz_data["type"]
}
return render_template("quiz.html", data=data)
else:
if session["current_quiz"]["type"] == "choose":
data = {
"wrong_sentence": session["current_quiz"]["wrong_sentence"],
"type": session["current_quiz"]["type"],
}
elif session["current_quiz"]["type"] == "option":
data = {
"problem_sentence": session["current_quiz"]["problem_sentence"],
"key_list": session["current_quiz"]["key_list"],
"type": session["current_quiz"]["type"]
}
# print(hint)
return render_template("quiz.html", data=data)
def index():
quiz_data = cache.get("quiz_data")
quiz_rows = copy.deepcopy(quiz_data)
return render_template("index_new.html")
