Squashed commit of the following:

commit 937843a65a6e0e65f6ee54216d975b259a3f8b16
Author: Brad Miller <[email protected]>
Date:   Fri Oct 21 09:11:53 2022 -0500

    Turn on ethical ad experiment

commit 210ffb8
Author: Brad Miller <[email protected]>
Date:   Thu Oct 20 11:36:27 2022 -0500

    Fix: remove lint

commit bce03ca
Author: Brad Miller <[email protected]>
Date:   Thu Oct 20 11:28:25 2022 -0500

    Add: docs

    Also, refactor to extract an add_flashcard function so it is not embedded in the updateLastPage function

commit c8f2661
Author: Brad Miller <[email protected]>
Date:   Thu Oct 20 09:50:21 2022 -0500

    New: restore functionality for ad-hoc practice

commit ee094ae
Author: Brad Miller <[email protected]>
Date:   Wed Oct 19 16:48:40 2022 -0500

    Start the adhoc practice update

Author: bnmnetp

bookserver/crud.py

@@ -24,7 +24,7 @@
 from fastapi.exceptions import HTTPException
 from pydal.validators import CRYPT
 from sqlalchemy import and_, distinct, func, update
-from sqlalchemy.sql import select, text
+from sqlalchemy.sql import select, text, delete
 from starlette.requests import Request
 
 from . import schemas
@@ -48,6 +48,7 @@
     CourseAttribute,
     CourseInstructor,
     CourseInstructorValidator,
+    CoursePractice,
     Courses,
     CoursesValidator,
     Library,
@@ -70,6 +71,8 @@
     UserStateValidator,
     UserSubChapterProgress,
     UserSubChapterProgressValidator,
+    UserTopicPractice,
+    UserTopicPracticeValidator,
     runestone_component_dict,
 )
 
@@ -1007,3 +1010,116 @@ async def fetch_library_books():
 
 async def create_library_book():
     ...
+
+
+async def fetch_course_practice(course_name: str) -> CoursePractice:
+    """
+    Fetch the course_practice row for a given course.  The course practice row
+    contains the configuration of the practice feature for the given course.
+    """
+    query = (
+        select(CoursePractice)
+        .where(CoursePractice.course_name == course_name)
+        .order_by(CoursePractice.id.desc())
+    )
+    async with async_session() as session:
+        res = await session.execute(query)
+        return res.scalars().first()
+
+
+async def fetch_one_user_topic_practice(
+    user: AuthUserValidator,
+    last_page_chapter: str,
+    last_page_subchapter: str,
+    qname: str,
+) -> UserTopicPracticeValidator:
+    """
+    The user_topic_practice table contains information about each question (flashcard)
+    that a student is eligible to see for a given topic in a course.
+    A particular question should ony be in the table once per student.  This row also contains
+    information about scheduling and correctness to help the practice algorithm select the
+    best question to show a student.
+    """
+    query = select(UserTopicPractice).where(
+        (UserTopicPractice.user_id == user.id)
+        & (UserTopicPractice.course_name == user.course_name)
+        & (UserTopicPractice.chapter_label == last_page_chapter)
+        & (UserTopicPractice.sub_chapter_label == last_page_subchapter)
+        & (UserTopicPractice.question_name == qname)
+    )
+    async with async_session() as session:
+        res = await session.execute(query)
+        rslogger.debug(f"{res=}")
+        utp = res.scalars().one_or_none()
+        return UserTopicPracticeValidator.from_orm(utp)
+
+
+async def delete_one_user_topic_practice(qid: int) -> None:
+    """
+    Used by ad hoc question selection.  If a student un-marks a page as completed then if there
+    is a question from the page it will be removed from the set of possible flashcards a student
+    can see.
+    """
+    query = delete(UserTopicPractice).where(UserTopicPractice.id == qid)
+    async with async_session.begin() as session:
+        await session.execute(query)
+
+
+async def create_user_topic_practice(
+    user: AuthUserValidator,
+    last_page_chapter: str,
+    last_page_subchapter: str,
+    qname: str,
+    now_local: datetime.datetime,
+    now: datetime.datetime,
+    tz_offset: float,
+):
+    """
+    Add a question for the user to practice on
+    """
+    async with async_session.begin() as session:
+        new_entry = UserTopicPractice(
+            user_id=user.id,
+            course_name=user.course_name,
+            chapter_label=last_page_chapter,
+            sub_chapter_label=last_page_subchapter,
+            question_name=qname,
+            # Treat it as if the first eligible question is the last one asked.
+            i_interval=0,
+            e_factor=2.5,
+            next_eligible_date=now_local.date(),
+            # add as if yesterday, so can practice right away
+            last_presented=now - datetime.timedelta(1),
+            last_completed=now - datetime.timedelta(1),
+            creation_time=now,
+            timezoneoffset=tz_offset,
+        )
+        session.add(new_entry)
+
+
+async def fetch_qualified_questions(
+    base_course, chapter_label, sub_chapter_label
+) -> list[QuestionValidator]:
+    """
+    Return a list of possible questions for a given chapter and subchapter.  These
+    questions will all have the practice flag set to true.
+    """
+    query = select(Question).where(
+        (Question.base_course == base_course)
+        & (
+            (Question.topic == "{}/{}".format(chapter_label, sub_chapter_label))
+            | (
+                (Question.chapter == chapter_label)
+                & (Question.topic == None)  # noqa: E711
+                & (Question.subchapter == sub_chapter_label)
+            )
+        )
+        & (Question.practice == True)  # noqa: E712
+        & (Question.review_flag == False)  # noqa: E712
+    )
+    async with async_session() as session:
+        res = await session.execute(query)
+        rslogger.debug(f"{res=}")
+        questionlist = [QuestionValidator.from_orm(x) for x in res.scalars().fetchall()]
+
+    return questionlist

bookserver/models.py

@@ -756,3 +756,46 @@ class Library(Base, IdMixin):
 
 
 LibraryValidator = sqlalchemy_to_pydantic(Library)
+
+
+# Tables for practice feature
+#
+class CoursePractice(Base, IdMixin):
+    __tablename__ = "course_practice"
+    auth_user_id = Column(ForeignKey("auth_user.id", ondelete="CASCADE"))
+    course_name = Column(String(512))
+    start_date = Column(Date)
+    end_date = Column(Date)
+    max_practice_days = Column(Integer)
+    max_practice_questions = Column(Integer)
+    day_points = Column(Float(53))
+    question_points = Column(Float(53))
+    questions_to_complete_day = Column(Integer)
+    graded = Column(Integer)
+    spacing = Column(Integer)
+    interleaving = Column(Integer)
+    flashcard_creation_method = Column(Integer)
+
+
+CoursePracticeValidator = sqlalchemy_to_pydantic(CoursePractice)
+
+
+class UserTopicPractice(Base, IdMixin):
+    __tablename__ = "user_topic_practice"
+
+    user_id = Column(ForeignKey("auth_user.id", ondelete="CASCADE"))
+    course_name = Column(String(512))
+    chapter_label = Column(String(512))
+    sub_chapter_label = Column(String(512))
+    question_name = Column(String(512))
+    i_interval = Column(Integer, nullable=False)
+    e_factor = Column(Float(53), nullable=False)
+    last_presented = Column(DateTime)
+    last_completed = Column(DateTime)
+    creation_time = Column(DateTime)
+    q = Column(Integer, nullable=False, default=0)
+    next_eligible_date = Column(Date)
+    timezoneoffset = Column(Integer)
+
+
+UserTopicPracticeValidator = sqlalchemy_to_pydantic(UserTopicPractice)

bookserver/routers/books.py

@@ -289,6 +289,7 @@ async def serve_page(
         and course_row.base_course != "csawesome"
         and course_row.base_course != "mobilecsp"
         and course_row.courselevel != "high"
+        and course_row.course_name != course_row.base_course
         and "supporter" not in course_attrs
     ):
         show_rs_banner = True
@@ -324,6 +325,7 @@ async def serve_page(
         pagepath=pagepath,
         canonical_host=canonical_host,
         show_rs_banner=show_rs_banner,
+        show_ethical_ad=True,
         **course_attrs,
     )
     # See `templates <https://fastapi.tiangolo.com/advanced/templates/>`_.

bookserver/routers/rslogging.py

@@ -11,7 +11,7 @@
 # Standard library
 # ----------------
 import json
-from datetime import datetime
+from datetime import datetime, timedelta
 import re
 from typing import Optional
 
@@ -31,11 +31,17 @@
     create_user_chapter_progress_entry,
     create_user_state_entry,
     create_user_sub_chapter_progress_entry,
+    create_user_topic_practice,
     EVENT2TABLE,
+    delete_one_user_topic_practice,
     fetch_last_page,
+    fetch_course,
+    fetch_course_practice,
+    fetch_one_user_topic_practice,
     fetch_user_chapter_progress,
     fetch_user_sub_chapter_progress,
     fetch_user,
+    fetch_qualified_questions,
     is_server_feedback,
     update_sub_chapter_progress,
     update_user_state,
@@ -257,12 +263,17 @@ async def same_class(user1: AuthUserValidator, user2: str) -> bool:
 # --------------
 # see :ref:`processPageState`
 @router.post("/updatelastpage")
-async def updatelastpage(request: Request, request_data: LastPageDataIncoming):
+async def updatelastpage(
+    request: Request,
+    request_data: LastPageDataIncoming,
+    RS_info: Optional[str] = Cookie(None),
+):
     if request_data.last_page_url is None:
         return  # todo:  log request_data, request.args and request.env.path_info
     if request.state.user:
         lpd = request_data.dict()
         rslogger.debug(f"{lpd=}")
+        user = request.state.user
 
         # last_page_url is going to be .../ns/books/published/course/chapter/subchapter.html
         # We will treat the second to last element as the chapter and the final element
@@ -290,11 +301,61 @@ async def updatelastpage(request: Request, request_data: LastPageDataIncoming):
         rslogger.debug("Not Authorized for update last page")
         raise HTTPException(401)
 
-        # todo: practice stuff came after this -- it does not belong here. But it needs
-        # to be ported somewhere....
+    # If practice is self paced then when a student marks a page as complete
+    # we need to add flashcards.
+
+    practice_settings = await fetch_course_practice(user.course_name)
+    if RS_info:
+        values = json.loads(RS_info)
+        tz_offset = float(values["tz_offset"])
+    else:
+        tz_offset = 0
+
+    if practice_settings and practice_settings.flashcard_creation_method == 0:
+        await add_flashcard(request_data, lpd, user, tz_offset)
+
     return make_json_response(detail="Success")
 
 
+async def add_flashcard(
+    request_data: LastPageDataIncoming,
+    lpd: dict,
+    user: AuthUserValidator,
+    tz_offset: float,
+) -> None:
+
+    rslogger.debug("Updating Practice Questions")
+    # Since each authenticated user has only one active course, we retrieve the course this way.
+    course = await fetch_course(user.course_name)
+
+    # We only retrieve questions to be used in flashcards if they are marked for practice purpose.
+    questions = await fetch_qualified_questions(
+        course.base_course, lpd["last_page_chapter"], lpd["last_page_subchapter"]
+    )
+    if len(questions) > 0:
+        now = datetime.utcnow()
+        now_local = now - timedelta(hours=tz_offset)
+        existing_flashcards = await fetch_one_user_topic_practice(
+            user,
+            lpd["last_page_chapter"],
+            lpd["last_page_subchapter"],
+            questions[0].name,
+        )
+        # There is at least one qualified question in this subchapter, so insert a flashcard for the subchapter.
+        if request_data.completion_flag == 1 and existing_flashcards is None:
+            await create_user_topic_practice(
+                user,
+                lpd["last_page_chapter"],
+                lpd["last_page_subchapter"],
+                questions[0].name,
+                now_local,
+                now,
+                tz_offset,
+            )
+        if request_data.completion_flag == 0 and existing_flashcards is not None:
+            await delete_one_user_topic_practice(existing_flashcards.id)
+
+
 # _getCompletionStatus
 # --------------------
 @router.get("/getCompletionStatus")