def create_card():
if request.method == "GET":
all_decks = Deck.query.filter_by(user_id=g.user.id)
error = ""
if all_decks is None:
error += "You have not created any deck yet."
return render_template("dashboard/cards/_create.html",
decks=all_decks,
error=error)
else:
front = request.form.get("front")
back = request.form.get("back")
deck_id = request.form.get("deck_id")
user = g.user
error = ""
if not front or not back or not deck_id:
error += "front back and deck_id fields are required."
if Deck.query.filter_by(id=deck_id).first() is None:
error += "\nSelected deck does not exist"
if not error:
new_card = Card(
front=front,
back=back,
deck_id=deck_id,
user_id=user.id,
state="Active",
)
new_card.save()
redis_cache.delete(f"user:{g.user.id}all_cards_dt")
redis_cache.delete(f"user:{g.user.id}deck_id:{deck_id}")
return jsonify("Success")
return jsonify(error)
def test_get_next_card(self, login, card, plan, decks, study_session,
client):
login()
study_session.update(state="Studying")
res = client.post(
f"deck/{decks[0].id}/study/{study_session.id}/next",
data={
"card_id": card.id,
"state": "Known"
},
)
assert 200 == res.status_code
study_session.update(state="Studying")
second_card = Card(
front="test front",
back="test back",
user_id=card.user_id,
deck_id=decks[0].id,
)
second_card.save()
res = client.post(
f"deck/{decks[0].id}/study/{study_session.id}/next",
data={
"card_id": card.id,
"state": "Known"
},
)
assert 200 == res.status_code
res_data = res.get_json()
assert res_data["status"] == 1, "Should return a valid next card"
def card(client, decks, user):
back = (
"Dynamic Programming (DP) is an algorithmic technique for solving and"
"optimization problem by breaking it down into simpler subproblems and"
"utilizing the fact that the optimal solution to the overall problem"
"depends upon the optimal solution to its subproblems.")
card = Card(
front="What is dynamic programming",
back=back,
user_id=user.id,
deck_id=decks[1].id,
)
card.save()
return card
def test_bulk_delete_cards(self, card, login, client):
login()
card_2 = Card(
front="Test Front",
back="Test back",
user_id=card.user_id,
deck_id=card.deck_id,
)
card_2.save()
res = client.post(
"/card/bulk/delete",
data={"data": json.dumps([card.id, card_2.id])},
)
assert 200 == res.status_code, "Should return a 200 status code"
assert Card.query.filter_by(id=card.id).first() is None
assert Card.query.filter_by(id=card_2.id).first() is None
def delete_card(card_id):
if request.method == "POST":
card = Card.get_by_user_or_404(card_id, g.user.id)
card.delete()
redis_cache.delete(f"user:{g.user.id}all_cards_dt")
redis_cache.delete(f"user:{g.user.id}deck_id:{card.deck_id}")
return jsonify({"status": 1, "message": "Card deleted successfully"})
def study_deck(deck_id):
"""Study a deck"""
deck = Deck.get_by_user_or_404(deck_id, g.user.id)
study_session = (db.session.query(StudySession).filter(
StudySession.deck_id == deck.id,
StudySession.user_id == g.user.id,
or_(StudySession.state == "Studying"),
).first())
if study_session is None:
study_session = StudySession(
user_id=g.user.id,
deck_id=deck.id,
known=0,
unknown=0,
state="Studying",
)
study_session.save()
deck.state = "Studying"
deck.save()
redis_cache.delete(f"user:{g.user.id}deck_id:{deck.id}")
study_plan = (StudyPlan.query.filter_by(
user_id=g.user.id,
state="Active").order_by(StudyPlan.date_created.desc()).first())
first_card = Card.get_next_card(study_session.id, deck_id)
session["active_study_session"] = study_session.to_json
session["active_deck"] = deck.to_json
session["active_card"] = first_card.to_json if first_card else None
return render_template(
"dashboard/decks/_study.html",
deck=deck.to_json,
study_session=study_session,
study_plan=study_plan,
first_card=first_card,
)
def bulk_delete_cards():
"""Bulk delete cards"""
if request.method == "POST":
data = json.loads(request.form.get("data", []))
for card_id in data:
card = Card.get_by_user_or_404(card_id, g.user.id)
card.delete()
redis_cache.delete(f"user:{g.user.id}all_cards_dt")
redis_cache.delete(f"user:{g.user.id}deck_id:{card.deck_id}")
return jsonify({"status": 1, "message": "Cards deleted successfully"})
def get_next_study_card(deck_id, study_session_id):
if request.method == "POST":
study_session = StudySession.get_by_user_or_404(
study_session_id, g.user.id)
if study_session.state != "Studying":
abort(400)
deck = Deck.get_by_user_or_404(deck_id, g.user.id)
card_state = request.form.get("state", "")
card_id = request.form.get("card_id", None)
if card_state not in ("Known", "Unknown") or not card_id:
abort(400)
# Create a study session log and update the study_session
log = StudySessionLog(study_session_id=study_session_id,
card_id=card_id,
state=card_state)
log.save()
if card_state == "Known":
study_session.update(known=StudySession.known + 1)
else:
study_session.update(unknown=StudySession.unknown + 1)
session["active_deck"] = deck.to_json
session["active_study_session"] = study_session.to_json
next_card = Card.get_next_card(study_session_id, deck_id)
status, data = 0, {
"active_deck": deck.to_json,
"active_study_session": study_session.to_json,
"active_card": None,
}
markup = None
if next_card is not None:
data["active_card"] = next_card.to_json
status = 1
message = "Study Session Studying"
session["active_card"] = next_card.to_json
session["previous_study_session"] = None
else:
deck.update(state="Complete")
StudySession.query.get(study_session.id).update(state="Complete")
session["active_card"] = None
message = "Study Session Complete"
markup = render_template(
"dashboard/decks/partials/session_stats.html",
previous_study_session=study_session,
)
redis_cache.delete(f"user:{g.user.id}deck_id:{deck_id}")
return jsonify({
"status": status,
"message": message,
"data": data,
"markup": markup
})
def edit_card(card_id):
if request.method == "POST":
card = Card.get_by_user_or_404(card_id, g.user.id)
state = request.form.get("state", card.state)
if state not in ("Active", "Disabled"):
abort(400)
card.update(
front=request.form.get("front", card.front),
back=request.form.get("back", card.back),
deck_id=request.form.get("deck_id", card.deck_id),
state=state,
)
redis_cache.delete(f"user:{g.user.id}all_cards_dt")
redis_cache.delete(f"user:{g.user.id}deck_id:{card.deck_id}")
return jsonify("OK")
def bulk_add_cards(deck_id):
data = json.loads(request.form.get("data"))
insert_cards = []
for card in data:
insert_cards.append(
Card(
front=card["front"],
back=card["back"],
deck_id=deck_id,
user_id=g.user.id,
))
db.session.bulk_save_objects(insert_cards)
db.session.commit()
redis_cache.delete(f"user:{g.user.id}all_cards_dt")
redis_cache.delete(f"user:{g.user.id}deck_id:{deck_id}")
return jsonify({"status": 1, "message": "Cards added successfully"})
def test_card_model(self, user, decks):
test_card = Card(
front="What is the air velocity of unladen swallow",
back="African or European?",
user_id=user.id,
deck_id=decks[1].id,
)
test_card.save()
assert test_card.state == "Active", "Should be saved with an Active state"
test_card.update(state="Solved")
assert test_card.state == "Solved", "State should be Solved"
Card.query.filter_by(back="African or European?").first().delete()
assert (
Card.query.filter_by(back="African or European?").first() is None
), "Should delete the card"
def get_card(card_id):
target_card = Card.get_by_user_or_404(card_id, g.user.id)
return jsonify(target_card.to_json)