cleaning templates, getting levels are party counts cached properly

2026-04-29 21:32:06 -04:00
parent 15342552f1
commit 0171a05c19
9 changed files with 157 additions and 101 deletions
--- a/app.py
+++ b/app.py
@@ -19,39 +19,73 @@ def index():

@app.route('/party', methods = ["GET","POST"])
 def party():
-  if request.method == "GET":
-    count = request.args.get("count", default=4, type=int)
-    level = request.args.get("level", default=1, type=int)
-  adv_party = returnParty(count, level) 
-  resp = make_response(render_template("party_sheet.html", adv_party=adv_party, count=count, level=level))
-  # make a cookie for each character
-  # this took a while to figure out, json alone was too large, b64 encoded json was too large, but it turns out you can compress json as a cookie
-  for character in adv_party.adventurers:
-    cookie_string = str(character.id)
-    char_json = json.dumps(character.get_json())
-    compressed = zlib.compress(char_json.encode())
-    cookie_data = base64.urlsafe_b64encode(compressed).decode()
-    resp.set_cookie(cookie_string, cookie_data)
-  return resp
-#  return render_template("party_sheet.html", adv_party=adv_party, count=count, level=level)
+    stored_adv_party = []
+    stored_count = None
+    stored_level = None
+    if request.method == "GET":
+        count = request.args.get("count", default=4, type=int)
+        level = request.args.get("level", default=1, type=int)
+        cache = request.args.get("cache", default='true', type=str)
+        adv_party = returnParty(count, level) 
+        # check for cookies present
+        if request.cookies:
+            print('there are cookies')
+            stored_count = len(request.cookies)
+            #print(request.cookies)
+            for c in request.cookies:
+                if c.startswith('adv'):
+                    cookie_encoded = request.cookies[c]
+                    cookie_compressed = base64.urlsafe_b64decode(cookie_encoded)
+                    character_dict = json.loads(zlib.decompress(cookie_compressed).decode())
+                    new_char = createCharacterWithDict(character_dict)
+                    stored_level = new_char.level
+                    stored_adv_party.append(new_char)
+            # if request arguments match the adventure party count & level stored in the cookies, just use the cookies
+            if cache == 'true':
+                print('caching is true')
+                if level != stored_level:
+                    print(f'change party level to {level}')
+                    for adv in stored_adv_party:
+                        print('...editing')
+                        adv.set_level(level)
+                        print(adv.level)
+                if count == stored_count:
+                    print('counts and levels are the same')
+                    adv_party.set_party(stored_adv_party, count, level)
+                if count > stored_count:
+                    print('extend the party!')
+                    extension = count - stored_count
+                    more_party_members = returnParty(extension,level).adventurers
+                    extended_party = stored_adv_party + more_party_members
+                    adv_party.set_party(extended_party, count, level)
+                if count < stored_count:
+                    print('reduce the party!')
+                    reduction = count - stored_count
+                    reduced_party = stored_adv_party[:reduction]
+                    adv_party.set_party(reduced_party, count, level)
+
+
+        # generate page
+        response = make_response(render_template("party_sheet.html", adv_party=adv_party, count=count, level=level, cache=cache))
+        # make a cookie for each character
+        # this took a while to figure out, json was too large, b64 encoded json was too large, but it turns out you can compress json as a cookie
+        for character in adv_party.adventurers:
+            cookie_string = character.identifier
+            char_json = json.dumps(character.get_json())
+            compressed = zlib.compress(char_json.encode())
+            cookie_data = base64.urlsafe_b64encode(compressed).decode()
+            response.set_cookie(cookie_string, cookie_data)
+        return response

@app.route('/character', methods = ["GET","POST"])
 def characters():
-  if request.method == "GET":
-    c_id = str(request.args.get("id", default=0, type=int))
-    cookie_encoded = request.cookies[c_id]
-    cookie_compressed = base64.urlsafe_b64decode(cookie_encoded)
-    character_dict = json.loads(zlib.decompress(cookie_compressed).decode())
-    chosen_class = character_dict['player_class']
-    c_id = character_dict['id']
-    level = character_dict['level']
-    adv_dict = Adventurer.get_subclass_dict()
-    chosen_class = adv_dict[chosen_class]
-    # note, i wonder if i can find a way to use the dict in a one liner, like from hw1
-    # makes a new character of the correct player class
-    new_char = chosen_class(c_id=c_id, level=level)
-    # loads in all the values from the dict
-    for k, v in character_dict.items():
-        # https://realpython.com/ref/builtin-functions/setattr/
-        setattr(new_char,k, v)
-  return render_template("character.html", character=new_char)
+    if request.method == "GET":
+        c_id = str(request.args.get("id", default=0, type=str))
+        if request.cookies and c_id:
+            cookie_encoded = request.cookies[c_id]
+            cookie_compressed = base64.urlsafe_b64decode(cookie_encoded)
+            character_dict = json.loads(zlib.decompress(cookie_compressed).decode())
+            new_char = createCharacterWithDict(character_dict)
+        else:
+            new_char = Adventurer(1,1)
+    return render_template("character.html", character=new_char)