Added sequential iteration feature with persistant uid

app.py

@@ -1,13 +1,13 @@
 # app.py
 from flask import Flask, request, jsonify, send_file
 import random
-from datetime import date  # used for daily verse
+from datetime import date, datetime  # used for daily verse
 import sqlite3
 import string  # for literals
 import json  # for dictionary
 import hunspell  # for spell checking
 
-DEBUG = 0
+DEBUG = 2
 
 """
 To-do:
@@ -19,7 +19,6 @@ Styles
 Bible Reading Plan
 Bible Reader
 Rich: <hr> on each comma
-find: handle ending with :
 find: handle ending with ,
 """
 
@@ -71,7 +70,7 @@ def lookup_bookname(book_id):
     ).fetchone()
     if result:
         result = result[0]
-    dbg2("lookup_bookname.result = '{}'".format(result))
+    dbg3("lookup_bookname.result = '{}'".format(result))
     return result
 
 
@@ -149,23 +148,27 @@ def lookup_contains_exact(kw):
     return results
 
 
-def ref_input_cleaning(ref, valid_chars=(string.ascii_letters + string.digits + ":-,")):
-    dbg2("ref_input_cleaning({})".format(ref))
+def ref_input_cleaning(
+    ref, valid_chars=(string.ascii_letters + string.digits + ":-,"), ref_search=True
+):
+    dbg3("ref_input_cleaning({})".format(ref))
     ref = ref.replace(" ", "")
-    if ref.count(":") != 1:
+    if ref.count(":") != 1 and ref_search:
         dbg2("ref_input_cleaning.if ref.count(:): TRUE")
         dbg2("  -> Assuming user wanted entire chapter")
         ref += ":-"
-    if ref.count("-") > 1:
+    if ref.endswith(":"):
+        ref += "-"
+    if ref.count("-") > 1 and ref_search:
         dbg2("ref_input_cleaning.if ref.count(-): TRUE")
         return False
-    if not ref[-1].isdigit() and ref[-1] != "-":
+    if not ref[-1].isdigit() and ref[-1] != "-" and ref_search:
         dbg2("ref_input_cleaning.if ref[-1] TRUE")
         return False
     ref = list(ref)
     # preserve book number if we can guess the first
     # character is a number and 3nd is a letter
-    if ref[0].isdigit() and ref[1].isalpha():
+    if ref[0].isdigit() and ref[1].isalpha() and ref_search:
         prefix = ref.pop(0) + " "
     else:
         prefix = ""
@@ -177,7 +180,10 @@ def ref_input_cleaning(ref, valid_chars=(string.ascii_letters + string.digits +
     # Was there a problem?
     if len(cleaned_ref) == 0:
         return False
-    return prefix + "".join(cleaned_ref).capitalize()
+    if ref_search:
+        return prefix + "".join(cleaned_ref).capitalize()
+    else:
+        return "".join(cleaned_ref)
 
 
 def search_input_cleaning(
@@ -271,8 +277,10 @@ def return_dict_rich(ref, defs):
 
 
 @app.get("/show")
-def show():
+def show(kw=None, get_start_verse_id=False):
     ref = request.args.get("kw", None)
+    if kw:
+        ref = kw
     if ref is None:
         return send_file("html/show.html")
     dbg("show({})".format(ref))
@@ -312,6 +320,8 @@ def show():
         if not ref_book_id:
             return "Invalid Query"
         start_verse_id = get_verse_id(ref_book_id, ref_chapter, start_verse)
+        if get_start_verse_id:
+            return start_verse_id
         if end_verse:
             end_verse_id = get_verse_id(ref_book_id, ref_chapter, end_verse)
         dbg2("show.start_verse_id({})".format(start_verse_id))
@@ -480,3 +490,74 @@ def reading_plan():
     # should default to the entire Bible in 1 year.
     # should start today() and end today()+1year
     # Should return a calender with date and verse range.
+
+
+@app.get("/seq")
+def sequential_read(start=0, num=1, uid=None, getuid=False):
+    # /seq?uid=1
+    uid = request.args.get("uid", uid)
+    getuid = request.args.get("getuid", getuid)
+    start = request.args.get("start", start)
+    try:
+        num = int(request.args.get("num", num))
+    except ValueError:
+        return "Invalid num argument"
+    if not uid or not getuid:
+        return send_file("html/seq.html")
+    seq_conn = sqlite3.connect("data/seq.db")
+    seq_cur = seq_conn.cursor()
+    last_used = str(datetime.now())
+    num -= 1  # 0 will mean "next"
+    if num < 0:
+        return jsonify({"error":"You may only increment forward."})
+
+    if getuid:
+        import uuid
+
+        if start:
+            start = verse_ids.index(int(show(kw=start, get_start_verse_id=True)))
+        uid = str(uuid.uuid4())
+        seq_cur.execute(
+            "INSERT INTO reading_tracker VALUES('{}', {}, '{}')".format(
+                uid, start, last_used
+            )
+        )
+        seq_conn.commit()
+        dbg2("Created new UID: {}".format(uid))
+        return "Your new UID is: {}".format(uid)
+    uid = ref_input_cleaning(uid, ref_search=False)
+    try:
+        nextverse = seq_cur.execute(
+            "SELECT verse FROM reading_tracker WHERE uid = '{}'".format(uid)
+        ).fetchone()[0]
+        dbg2("Queried UID {} on verse {}".format(uid, nextverse))
+    except TypeError:
+        dbg2("Invalid UID {}".format(uid))
+        return jsonify({"error":"UID Invalid or purged"})
+    if len(verse_ids) < (nextverse + num):
+        # Correct our range to go to ceiling to prevent IndexError
+        diff = len(verse_ids) - (nextverse + num)
+        num = diff - num
+    start_verse = verse_ids[nextverse]
+    end_verse = verse_ids[nextverse + num]
+    result_list = lookup_by_verse_id(start_verse, end_verse)
+    response_list = response_multi(result_list)
+
+    dbg2(
+        "SQL : UPDATE reading_tracker SET verse = {}, last_used = '{}' WHERE uid = '{}'".format(
+            nextverse + num, last_used, uid
+        )
+    )
+    seq_cur.execute(
+        "UPDATE reading_tracker SET verse = {}, last_used = '{}' WHERE uid = '{}'".format(
+            nextverse + num + 1, last_used, uid
+        )
+    )
+    seq_conn.commit()
+    arg_view = request.args.get("view", None)
+    if arg_view == "plain" or arg_view == "rich":
+        response = "<br>".join(response_list)
+    else:
+        response = jsonify(response_list)
+
+    return response