maint, Top monthly scores, Top scores for month.

Maint works, it builds up the monthly score table.

Still working on calendar panel "update".

db.cpp

@@ -52,9 +52,9 @@ retry:
         "CREATE TABLE IF NOT EXISTS scores ( \"username\" TEXT, \"when\" "
         "INTEGER, \"date\" INTEGER, \"hand\" INTEGER, \"won\" INTEGER, "
         "\"score\" INTEGER, PRIMARY KEY(\"username\", \"date\", \"hand\"));");
-    db.exec("CREATE TABLE IF NOT EXISTS monthly (	\"month\"	"
-            "INTEGER, \"username\"	TEXT, \"days\"	INTEGER, 	"
-            "\"score\"	INTEGER, PRIMARY KEY(\"month\",\"username\") );");
+    db.exec("CREATE TABLE IF NOT EXISTS \"monthly\" ( \"month\"	INTEGER, "
+            "\"username\" TEXT, \"days\" INTEGER, \"hands_won\" INTEGER, "
+            "\"score\" INTEGER, PRIMARY KEY(\"month\",\"username\") );");
   } catch (std::exception &e) {
     if (get_logger) {
       get_logger() << "create_tables():" << std::endl;
@@ -311,43 +311,28 @@ retry:
  *
  * @return std::map<time_t, std::vector<scores_data>>
  */
-std::map<time_t, std::vector<scores_data>> DBData::getScores(void) {
-  std::map<time_t, std::vector<scores_data>> scores;
+std::vector<scores_data> DBData::getScores(int limit) {
+  std::vector<scores_data> scores;
   int tries = 0;
 
 retry:
   try {
     SQLite::Statement stmt(
         db, "SELECT `date`,username,SUM(score),SUM(won) FROM scores "
-            "GROUP BY `date`,username ORDER BY `date`,SUM(score) DESC;");
-    time_t current = 0;
-    std::vector<scores_data> vsd;
+            "GROUP BY `date`,username ORDER BY SUM(score) DESC LIMIT ?;");
+    stmt.bind(1, limit);
+    //        db, "SELECT `date`,username,SUM(score),SUM(won) FROM scores "
+    //            "GROUP BY `date`,username ORDER BY `date`,SUM(score) DESC;");
 
     while (stmt.executeStep()) {
-      time_t the_date = stmt.getColumn(0);
-
-      if (current == 0) {
-        // ok, we've got the first one!
-        current = the_date;
-      } else {
-        // Ok, are we on another date now?
-        if (the_date != current) {
-          scores[current] = std::move(vsd);
-          vsd.clear();
-          current = the_date;
-        }
-      }
       scores_data sd;
+      sd.date = (long)stmt.getColumn(0);
       sd.user = (const char *)stmt.getColumn(1);
-      sd.date = the_date;
       sd.score = stmt.getColumn(2);
       sd.won = stmt.getColumn(3);
-      vsd.push_back(sd);
-    }
-    if (!vsd.empty()) {
-      scores[current] = std::move(vsd);
+      scores.push_back(sd);
     }
-    vsd.clear();
+
   } catch (std::exception &e) {
     if (get_logger) {
       get_logger() << "getScores(): " << std::endl;
@@ -371,6 +356,58 @@ retry:
   return scores;
 }
 
+/**
+ * @brief Gets scores, time_t is day, vector has user and scores sorted highest
+ * to lowest.
+ *
+ * (	\"month\", \"username\"	, \"days\",	hands_won, "\"score\"
+ *
+ * @return std::map<time_t, std::vector<scores_data>>
+ */
+std::vector<monthly_data> DBData::getMonthlyScores(int limit) {
+  std::vector<monthly_data> scores;
+  scores.reserve(limit);
+  int tries = 0;
+
+retry:
+  try {
+    SQLite::Statement stmt(
+        db, "SELECT month, username, days, hands_won, score FROM monthly "
+            "ORDER BY score DESC LIMIT ?;");
+    stmt.bind(1, limit);
+
+    while (stmt.executeStep()) {
+      monthly_data data;
+      data.date = (long)stmt.getColumn(0);
+      data.user = (const char *)stmt.getColumn(1);
+      data.days = stmt.getColumn(2);
+      data.hands_won = stmt.getColumn(3);
+      data.score = stmt.getColumn(4);
+      scores.push_back(data);
+    }
+  } catch (std::exception &e) {
+    if (get_logger) {
+      get_logger() << "getMonthlyScores( " << limit << "): " << std::endl;
+      get_logger() << "SQLite exception: " << e.what() << std::endl;
+    }
+    scores.clear();
+    if (strcmp(e.what(), DBLOCK) == 0) {
+      ++tries;
+      if (tries < locked_retries) {
+        retry_wait();
+        goto retry;
+      }
+      if (get_logger)
+        get_logger() << "giving up! " << locked_retries << " retries."
+                     << std::endl;
+    }
+  }
+  if (tries > 0)
+    if (get_logger)
+      get_logger() << "success after " << tries << std::endl;
+  return scores;
+}
+
 /**
  * @brief Get hands played per day
  *
@@ -419,7 +456,8 @@ retry:
 /**
  * @brief When has the user played?
  *
- * This returns a map of date (time_t), and number of hands played on that date.
+ * This returns a map of date (time_t), and number of hands played on that
+ * date.
  *
  * @return std::map<time_t, long>
  */
@@ -492,7 +530,7 @@ struct month_stats {
 /**
  * @brief This will expire out old scores
  *
- * @todo implement, but don't throw away high scores.
+ * Merges scores into monthly table.
  *
  * @param month_first_t
  *
@@ -526,8 +564,8 @@ void DBData::expireScores(time_t month_first_t) {
     stmt.bind(1, (long)month_first_t);
 
     while (stmt.executeStep()) {
-      // get time_t, conver to time_point, find first of month, convert back to
-      // time_t
+      // get time_t, conver to time_point, find first of month, convert back
+      // to time_t
       std::chrono::_V2::system_clock::time_point date;
 
       date = std::chrono::system_clock::from_time_t((long)stmt.getColumn(0));
@@ -591,7 +629,8 @@ void DBData::expireScores(time_t month_first_t) {
     for (auto key : monthly) {
       /*
             if (get_logger) {
-              get_logger() << key.first.date << ":" << key.first.username << " "
+              get_logger() << key.first.date << ":" << key.first.username << "
+         "
                            << key.second.score << std::endl;
             }
       */
@@ -647,6 +686,29 @@ std::string convertDateToDateScoreFormat(time_t tt) {
   return date;
 }
 
+/**
+ * @brief Format date to string.
+ *
+ * We use default "%0m/%0d/%Y", but can be configured by SysOp via
+ * config["date_score"] setting.  "%Y/%0m/%0d" for non-US?
+ * https://en.cppreference.com/w/cpp/io/manip/put_time
+ *
+ * @param tt
+ * @return std::string
+ */
+std::string convertDateToMonthlyFormat(time_t tt) {
+  std::stringstream ss;
+  if (config["date_monthly"]) {
+    std::string custom_format = config["date_monthly"].as<std::string>();
+    ss << std::put_time(std::localtime(&tt), custom_format.c_str());
+  } else {
+    ss << std::put_time(std::localtime(&tt), "%B %Y");
+  }
+
+  std::string date = ss.str();
+  return date;
+}
+
 void normalizeDate(std::chrono::_V2::system_clock::time_point &date) {
   time_t date_t = std::chrono::system_clock::to_time_t(date);
   normalizeDate(date_t);
@@ -692,4 +754,4 @@ void firstOfMonthDate(std::chrono::_V2::system_clock::time_point &date) {
     date -= 24h * (date_tm.tm_mday - 1);
   }
   normalizeDate(date);
-}
+}

db.h

@@ -23,6 +23,14 @@ typedef struct {
   int won;
 } scores_data;
 
+typedef struct {
+  time_t date;
+  std::string user;
+  int days;
+  int hands_won;
+  int score;
+} monthly_data;
+
 class DBData {
   SQLite::Database db;
   void create_tables(void);
@@ -53,7 +61,8 @@ public:
   void saveScore(time_t when, time_t date, int hand, int won, int score);
 
   std::vector<scores_details> getScoresOnDay(time_t date);
-  std::map<time_t, std::vector<scores_data>> getScores(void);
+  std::vector<monthly_data> getMonthlyScores(int limit = 10);
+  std::vector<scores_data> getScores(int limit = 10);
   std::map<time_t, int> getPlayed(void);
   void expireScores(time_t month_first_t);
 
@@ -65,5 +74,6 @@ void normalizeDate(std::chrono::_V2::system_clock::time_point &date);
 void normalizeDate(time_t &tt, int hour = 2);
 void firstOfMonthDate(std::chrono::_V2::system_clock::time_point &date);
 std::string convertDateToDateScoreFormat(time_t tt);
+std::string convertDateToMonthlyFormat(time_t tt);
 
 #endif

main.cpp

@@ -435,6 +435,11 @@ int main(int argc, char *argv[]) {
     update_config = true;
   }
 
+  if (!config["date_monthly"]) {
+    config["date_monthly"] = "%B %Y";
+    update_config = true;
+  }
+
   /*
     if (config["hands_per_day"]) {
       get_logger() << "hands_per_day: " << config["hands_per_day"].as<int>()
@@ -566,17 +571,34 @@ int main(int argc, char *argv[]) {
 
     case 2: // view scores
     {
-      door << door::cls;
+      // door << door::cls;
+      display_starfield(door, rng);
+      door << door::Goto(1, 2);
+
+      auto monthly_scores = spacedb.getMonthlyScores(10);
+      if (!monthly_scores.empty()) {
+        door << "The TOP monthly Scores:" << door::nl;
+      }
+      for (auto it : monthly_scores) {
+        time_t date = it.date;
+        std::string nice_date = convertDateToMonthlyFormat(date);
+        door << nice_date << " " << std::setw(18) << it.user << " " << it.score
+             << door::nl;
+      }
+      door << door::nl;
+
+      // I probably want JUST the top 10 here!
+
       auto all_scores = spacedb.getScores();
+      if (!all_scores.empty()) {
+        door << "The Top Scores for this Month:" << door::nl;
+      }
+
       for (auto it : all_scores) {
-        time_t on_this_date = it.first;
-        std::string nice_date = convertDateToDateScoreFormat(on_this_date);
-        door << "  *** " << nice_date << " ***" << door::nl;
 
-        for (auto sd : it.second) {
-          door << setw(15) << sd.user << " " << sd.won << " " << sd.score
-               << door::nl;
-        }
+        std::string nice_date = convertDateToDateScoreFormat(it.date);
+        door << "  *** " << nice_date << setw(15) << it.user << " " << it.won
+             << " " << it.score << door::nl;
       }
       door << "====================" << door::nl;
     }

play.cpp

@@ -122,7 +122,7 @@ int PlayCards::press_a_key(void) {
 }
 
 /**
- * @brief PLay
+ * @brief Play
  *
  * This will display the calendar (if needed), otherwise takes player into
  * play_cards using now() as play_day.
@@ -134,7 +134,6 @@ int PlayCards::play(void) {
   play_day = std::chrono::system_clock::now();
   normalizeDate(play_day);
 
-  int total_hands;
   if (config["hands_per_day"]) {
     total_hands = config["hands_per_day"].as<int>();
   } else
@@ -171,6 +170,24 @@ int PlayCards::play(void) {
 
   door << *calendar;
 
+  bool has_playable_day = false;
+  for (int x = 0; x < 31; ++x) {
+    int status = calendar_day_status[x];
+    if ((status == 0) or (status == 1)) {
+      has_playable_day = true;
+      break;
+    }
+  }
+
+  if (!has_playable_day) {
+    door << door::nl;
+    door << "Sorry, there are no days available to play." << door::nl;
+    int r = press_a_key();
+    if (r < 0)
+      return r;
+    return 'Q';
+  }
+
   door << door::nl;
   door << "Choose, eh? ";
   std::string toplay = door.input_string(3);
@@ -394,18 +411,20 @@ next_hand:
         next_quit_panel->update();
         door << *next_quit_panel;
 
+        // use some other variable here for what we get from the get_one_of.
+
         if (hand < total_hands) {
-          r = door.get_one_of("CQN");
+          r = door.get_one_of("CNQ");
         } else {
-          r = door.get_one_of("CQ");
+          r = door.get_one_of("CDQ");
         }
 
-        if (r == 0) {
+        if (r == 'C') {
           // continue
           redraw(false);
           break;
         }
-        if (r == 1) {
+        if ((r == 'D') or (r == 'Q')) {
           // Ok, we are calling it quits.
           // save score if > 0
           if (score >= 50) {
@@ -416,9 +435,9 @@ next_hand:
                          0, score);
           }
           in_game = false;
-          r = 'Q';
+          // r = 'Q';
         }
-        if (r == 2) {
+        if (r == 'N') {
           // no.  If you want to play the next hand, we have to save this.
           get_logger() << "SCORE: " << score << std::endl;
           time_t right_now = std::chrono::system_clock::to_time_t(
@@ -588,17 +607,23 @@ next_hand:
                 door << *next_quit_panel;
 
                 if (hand < total_hands) {
-                  r = door.get_one_of("QN");
+                  r = door.get_one_of("NQ");
                 } else {
-                  r = door.get_one_of("Q");
+                  r = door.get_one_of("DQ");
                 }
 
-                if (r == 1) {
+                if (r == 'N') {
                   hand++;
                   goto next_hand;
                 }
 
-                if (r == 0) {
+                in_game = false;
+                if (r == 'D') {
+                  // done?
+                  // maybe r = 'Q'; ?
+                }
+
+                if (r == 'Q') {
                   r = 'Q';
                 }
                 /*
@@ -612,7 +637,7 @@ next_hand:
                 }
                 r = 'Q';
                 */
-                in_game = false;
+                // in_game = false;
               }
             }
             // update the select_card marker!
@@ -841,9 +866,10 @@ std::unique_ptr<door::Panel> PlayCards::make_score_panel() {
   {
     std::string userString = "Name: ";
     userString += door.username;
-    door::Line username(userString, W);
-    username.setRender(svRender);
-    p->addLine(std::make_unique<door::Line>(username));
+    std::unique_ptr<door::Line> username =
+        std::make_unique<door::Line>(userString, W);
+    username->setRender(svRender);
+    p->addLine(std::move(username));
   }
   {
     door::updateFunction scoreUpdate = [this](void) -> std::string {
@@ -852,10 +878,11 @@ std::unique_ptr<door::Panel> PlayCards::make_score_panel() {
       return text;
     };
     std::string scoreString = scoreUpdate();
-    door::Line scoreline(scoreString, W);
-    scoreline.setRender(svRender);
-    scoreline.setUpdater(scoreUpdate);
-    p->addLine(std::make_unique<door::Line>(scoreline));
+    std::unique_ptr<door::Line> scoreline =
+        std::make_unique<door::Line>(scoreString, W);
+    scoreline->setRender(svRender);
+    scoreline->setUpdater(scoreUpdate);
+    p->addLine(std::move(scoreline));
   }
   {
     door::updateFunction timeUpdate = [this](void) -> std::string {
@@ -1035,7 +1062,7 @@ std::unique_ptr<door::Panel> PlayCards::make_command_panel(void) {
 }
 
 std::unique_ptr<door::Panel> PlayCards::make_next_panel(void) {
-  const int W = 50;
+  const int W = 50; // 50;
   std::unique_ptr<door::Panel> p = make_unique<door::Panel>(W);
   door::ANSIColor panelColor(door::COLOR::YELLOW, door::COLOR::GREEN,
                              door::ATTR::BOLD);
@@ -1044,17 +1071,13 @@ std::unique_ptr<door::Panel> PlayCards::make_next_panel(void) {
 
   door::updateFunction nextUpdate = [this](void) -> std::string {
     std::string text;
-    if (select_card == -1) {
-      // winner
-      if (hand < total_hands) {
-        text = " [N]ext Hand - [Q]uit";
-      } else
-        text = " All hands played - [Q]uit";
-    } else if (hand < total_hands) {
-      text = " [C]ontinue this hand - [N]ext Hand - [Q]uit";
-    } else {
-      text = " [C]ontinue this hand - [Q]uit";
-    }
+    if (select_card != -1)
+      text = "[C]ontinue this hand";
+
+    if (hand < total_hands)
+      text += "  [N]ext Hand  [Q]uit";
+    else
+      text += "  [D]one  [Q]uit";
     return text;
   };
 
@@ -1408,6 +1431,57 @@ PlayCards::current_month(std::chrono::_V2::system_clock::time_point now) {
   return text;
 }
 
+void PlayCards::update_calendar_days(time_t month_t) {
+  std::tm month_lt;
+  localtime_r(&month_t, &month_lt);
+
+  int this_month = month_lt.tm_mon;
+  int this_day = month_lt.tm_mday;
+  int this_year = month_lt.tm_year + 1900;
+  calendar_day_status.fill(0);
+
+  auto last_played = db.whenPlayed();
+  int play_days_ahead = 0;
+
+  if (config["play_days_ahead"]) {
+    play_days_ahead = config["play_days_ahead"].as<int>();
+  }
+
+  // until maint is setup, we need to verify that the month and year is
+  // correct.
+  for (auto played : last_played) {
+    get_logger() << "played " << played.first << " hands: " << played.second
+                 << std::endl;
+    time_t play_t = played.first;
+    std::tm played_tm;
+    localtime_r(&play_t, &played_tm);
+    if (get_logger) {
+      get_logger() << played_tm.tm_mon + 1 << "/" << played_tm.tm_mday << "/"
+                   << played_tm.tm_year + 1900 << " : " << played.second << " "
+                   << play_t << std::endl;
+    }
+    if ((played_tm.tm_mon == this_month) &&
+        (played_tm.tm_year + 1900 == this_year)) {
+      // Ok!
+      int hands = played.second;
+      if (hands < total_hands) {
+        calendar_day_status[played_tm.tm_mday - 1] = 1;
+      } else {
+        if (hands >= total_hands) {
+          calendar_day_status[played_tm.tm_mday - 1] = 2;
+        }
+      }
+    }
+  }
+
+  // mark days ahead as NNY.
+  for (int d = 0; d < month_last_day; ++d) {
+    if (this_day + play_days_ahead - 1 < d) {
+      calendar_day_status[d] = 3;
+    }
+  }
+}
+
 /**
  * make_calendar
  *
@@ -1423,8 +1497,11 @@ std::unique_ptr<door::Screen> PlayCards::make_calendar() {
    * we count things.  (Also last day of month + midnight -- means
    * we need maint ran!  No!)
    */
+  std::chrono::system_clock::time_point month =
+      std::chrono::system_clock::now();
+  // std::chrono::_V2::system_clock::time_point month =
+  // std::chrono::system_clock::now();
 
-  auto month = std::chrono::system_clock::now();
   time_t month_t = std::chrono::system_clock::to_time_t(month);
   // adjust to first day of the month
   std::tm month_lt;
@@ -1434,16 +1511,14 @@ std::unique_ptr<door::Screen> PlayCards::make_calendar() {
   int this_day = month_lt.tm_mday;
   int this_year = month_lt.tm_year + 1900;
 
-  if (month_lt.tm_mday > 1) {
-    month -= 24h * (month_lt.tm_mday - 1);
-  }
-  normalizeDate(month);
+  firstOfMonthDate(month);
   month_t = std::chrono::system_clock::to_time_t(month);
   calendar_day_t.fill(0);
   calendar_day_t[0] = month_t;
 
   get_logger() << "1st of Month is "
                << std::put_time(std::localtime(&month_t), "%c %Z") << std::endl;
+
   localtime_r(&month_t, &month_lt);
   const int FIRST_WEEKDAY = month_lt.tm_wday; // 0-6
 
@@ -1498,6 +1573,7 @@ std::unique_ptr<door::Screen> PlayCards::make_calendar() {
   }
 
   calendar_day_status.fill(0);
+  // update_calendar_days(month_t);
 
   auto last_played = db.whenPlayed();
   int play_days_ahead = 0;
@@ -1523,6 +1599,10 @@ std::unique_ptr<door::Screen> PlayCards::make_calendar() {
         (played_tm.tm_year + 1900 == this_year)) {
       // Ok!
       int hands = played.second;
+      if (get_logger) {
+        get_logger() << "hands " << hands << " total " << total_hands
+                     << std::endl;
+      }
       if (hands < total_hands) {
         calendar_day_status[played_tm.tm_mday - 1] = 1;
       } else {

play.h

@@ -47,6 +47,8 @@ private:
   std::unique_ptr<door::Panel> make_calendar_panel(void);
   std::unique_ptr<door::Screen> make_calendar(void);
 
+  void update_calendar_days(time_t month_t);
+
   std::string current_month(std::chrono::_V2::system_clock::time_point now);
   int press_a_key(void);