Fixed logging date format, added post_log shortcut

Author: tomasbedrich

pycaching/cache.py

@@ -8,7 +8,7 @@
 from pycaching.geo import Point
 from pycaching.trackable import Trackable
 from pycaching.log import Log
-from pycaching.util import parse_date, rot13, lazy_loaded
+from pycaching.util import parse_date, format_date, rot13, lazy_loaded
 
 # prefix _type() function to avoid colisions with cache type
 _type = type
@@ -532,28 +532,34 @@ def load_trackables(self, limit=float("inf")):
 
     def _load_log_page(self):
         log_page = self.geocaching._request(self.log_page_url)
-        # Find all valid log types for the cache
-        type_options = log_page.find_all("option")
-        valid_types = {o.get_text().lower(): o["value"] for o in type_options}
 
-        # Find all static data fields needed for log
-        hidden_elements = log_page.find_all("input", type=["hidden", "submit"])
-        return (valid_types, hidden_elements)
+        # find all valid log types for the cache (-1 kicks out "- select type of log -")
+        valid_types = {o.get_text().lower(): o["value"]
+                       for o in log_page.find_all("option") if o["value"] != "-1"}
+
+        # find all static data fields needed for log
+        hidden_inputs = log_page.find_all("input", type=["hidden", "submit"])
+        hidden_inputs = {i["name"]: i.get("value", "") for i in hidden_inputs}
+
+        # get user date format
+        date_format = log_page.find(
+            id="ctl00_ContentBody_LogBookPanel1_uxDateFormatHint").text.strip("()")
+
+        return valid_types, hidden_inputs, date_format
 
     def post_log(self, l):
         if not l.text:
             raise errors.ValueError("Log text is empty")
 
-        valid_types, hidden = self._load_log_page()
+        valid_types, hidden_inputs, date_format = self._load_log_page()
         if l.type.value not in valid_types:
             raise errors.ValueError("The Cache does not accept this type of log")
-        post = {field["name"]: (field["value"] if field.has_attr("value") else "")
-                for field in hidden}
-        post["ctl00$ContentBody$LogBookPanel1$btnSubmitLog"] = "Submit Log Entry"
 
-        # fill form from Log object
+        # assemble post data
+        post = hidden_inputs
+        post["ctl00$ContentBody$LogBookPanel1$btnSubmitLog"] = "Submit Log Entry"
         post["ctl00$ContentBody$LogBookPanel1$ddLogType"] = valid_types[l.type.value]
-        post["ctl00$ContentBody$LogBookPanel1$uxDateVisited"] = l.visited.strftime("%m/%d/%Y")
+        post["ctl00$ContentBody$LogBookPanel1$uxDateVisited"] = format_date(l.visited, date_format)
         post["ctl00$ContentBody$LogBookPanel1$uxLogInfo"] = l.text
 
         self.geocaching._request(self.log_page_url, method="POST", data=post)

pycaching/geocaching.py

@@ -2,10 +2,12 @@
 
 import logging
 import requests
+import datetime
 from urllib.parse import urljoin
 from mechanicalsoup import Browser
 from bs4 import BeautifulSoup
 from pycaching.cache import Cache, Type, Size
+from pycaching.log import Log, Type as LogType
 from pycaching.geo import Point
 from pycaching.trackable import Trackable
 from pycaching.errors import Error, NotLoggedInException, LoginFailedException
@@ -220,3 +222,8 @@ def load_cache(self, wp):
     def load_trackable(self, tid):
         """Return a cache by its TID."""
         return Trackable(self, tid)
+
+    def post_log(self, wp, text, type=LogType.found_it, date=datetime.date.today()):
+        """Post log for cache."""
+        l = Log(type=type, text=text, visited=date)
+        self.load_cache(wp).post_log(l)

pycaching/log.py

@@ -52,7 +52,7 @@ def visited(self, visited):
         if _type(visited) is str:
             visited = parse_date(visited)
         elif _type(visited) is not datetime.date:
-            raise ValueError(
+            raise errors.ValueError(
                 "Passed object is not datetime.date instance nor string containing a date.")
         self._visited = visited
 

pycaching/util.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
 import logging
+import re
 from datetime import datetime
 from pycaching import errors
 
@@ -48,6 +49,23 @@ def parse_date(raw):
     raise errors.ValueError("Unknown date format - '{}'.".format(raw))
 
 
+def format_date(date, user_date_format):
+    # parse user format
+    date_format = user_date_format.lower()
+    date_format = re.split("(\W+)", date_format)
+    formats = {
+        "dd": r'%d',
+        "d": r'%-d',
+        "mmm": r'%b',
+        "mm": r'%m',
+        "m": r'%-m',
+        "yyyy": r'%Y',
+        "yy": r'%y',
+    }
+    date_format = "".join((formats[c] if c in formats else c for c in date_format))
+    return date.strftime(date_format)
+
+
 def get_possible_attributes():
     """Returns dict of all possible attributes parsed from Groundspeak's website."""
 

test/test_cache.py

@@ -194,6 +194,19 @@ def test_load_logbook(self):
         for expected_author in ["Dudny-1995", "Sopdet Reviewer", "donovanstangiano83"]:
             self.assertIn(expected_author, log_authors)
 
+    def test_load_log_page(self):
+        expected_types = set((t.value for t in (LogType.found_it, LogType.didnt_find_it, LogType.note)))
+        expected_inputs = "__EVENTTARGET", "__VIEWSTATE"  # and more ...
+        expected_date_format = "d.M.yyyy"
+
+        # make request
+        valid_types, hidden_inputs, user_date_format = self.c._load_log_page()
+
+        self.assertSequenceEqual(expected_types, set(valid_types.keys()))
+        for i in expected_inputs:
+            self.assertIn(i, hidden_inputs.keys())
+        self.assertEqual(expected_date_format, user_date_format)
+
     @mock.patch.object(Cache, "_load_log_page")
     @mock.patch.object(Geocaching, "_request")
     def test_post_log(self, mock_request, mock_load_log_page):
@@ -204,7 +217,7 @@ def test_post_log(self, mock_request, mock_load_log_page):
             "write note": "4",
             "didn't find it": "3",
         }
-        mock_load_log_page.return_value = (valid_log_types, {})
+        mock_load_log_page.return_value = (valid_log_types, {}, "mm/dd/YYYY")
         test_log_text = "Test log."
 
         with self.subTest("empty log text"):

test/test_geocaching.py

@@ -116,6 +116,10 @@ def setUpClass(cls):
     def test_login(self):
         pycaching.login(_username, _password)
 
+    def test_geocode(self):
+        ref_point = Point(49.74774, 13.37752)
+        self.assertLess(great_circle(self.g.geocode("Pilsen"), ref_point).miles, 10)
+
     def test_load_cache(self):
         c = self.g.load_cache("GC4808G")
         self.assertEqual("Nekonecne ticho", c.name)
@@ -124,6 +128,6 @@ def test_load_trackable(self):
         t = self.g.load_trackable("TB1KEZ9")
         self.assertEqual("Lilagul #2: SwedenHawk Geocoin", t.name)
 
-    def test_geocode(self):
-        ref_point = Point(49.74774, 13.37752)
-        self.assertLess(great_circle(self.g.geocode("Pilsen"), ref_point).miles, 10)
+    def test_post_log(self):
+        # I refuse to write 30 lines of tests (mocking etc.) because of simple 2 lines of code
+        pass

test/test_util.py

@@ -3,7 +3,7 @@
 import unittest
 import datetime
 import itertools
-from pycaching.util import rot13, parse_date, get_possible_attributes
+from pycaching.util import rot13, parse_date, format_date, get_possible_attributes
 
 
 class TestModule(unittest.TestCase):
@@ -12,8 +12,8 @@ def test_rot13(self):
         self.assertEqual(rot13("Text"), "Grkg")
         self.assertEqual(rot13("abc'ř"), "nop'ř")
 
-    def test_date_parsing(self):
-        dates = (datetime.date(2014, 1, 30), datetime.date(2000, 1, 1), datetime.date(2020, 12, 13))
+    def test_parse_date(self):
+        dates = datetime.date(2014, 1, 30), datetime.date(2000, 1, 1), datetime.date(2020, 12, 13)
         patterns = ("%Y-%m-%d", "%Y/%m/%d", "%m/%d/%Y", "%d/%m/%Y",
                     "%d.%m.%Y", "%d/%b/%Y", "%d.%b.%Y", "%b/%d/%Y", "%d %b %y")
 
@@ -22,6 +22,35 @@ def test_date_parsing(self):
             formatted_date = datetime.datetime.strftime(date, pattern)
             self.assertEqual(date, parse_date(formatted_date))
 
+    def test_format_date(self):
+        date = datetime.date(2015, 1, 30)
+        cases = {
+            "d. M. yyyy": "30. 1. 2015",
+            "d.M.yyyy": "30.1.2015",
+            "d.MM.yyyy": "30.01.2015",
+            "d/M/yy": "30/1/15",
+            "d/M/yyyy": "30/1/2015",
+            "d/MM/yyyy": "30/01/2015",
+            "dd MMM yy": "30 Jan 15",
+            "dd.MM.yyyy": "30.01.2015",
+            "dd.MM.yyyy.": "30.01.2015.",
+            "dd.MMM.yyyy": "30.Jan.2015",
+            "dd/MM/yy": "30/01/15",
+            "dd/MM/yyyy": "30/01/2015",
+            "dd/MMM/yyyy": "30/Jan/2015",
+            "dd-MM-yy": "30-01-15",
+            "dd-MM-yyyy": "30-01-2015",
+            "d-M-yyyy": "30-1-2015",
+            "M/d/yyyy": "1/30/2015",
+            "MM/dd/yyyy": "01/30/2015",
+            "MMM/dd/yyyy": "Jan/30/2015",
+            "yyyy.MM.dd.": "2015.01.30.",
+            "yyyy/MM/dd": "2015/01/30",
+            "yyyy-MM-dd": "2015-01-30",
+        }
+        for user_format, ref_result in cases.items():
+            self.assertEqual(format_date(date, user_format), ref_result)
+
     def test_get_possible_attributes(self):
         attributes = get_possible_attributes()