-Polished/refactored code.

-Updated docs
-Turned off animations for charts.
-Fixed issue where Tasker will not render proper metadata for commitments with "Everyday" frequency.
-Releasing 0.1.1
-TODO:Polish code
-TODO:Start using temporary branches
-TODO:Fix bugs(like chart rendering) that happen with "Everyday"  commitments
-TODO:Inspect workflows for deleting commitments

Author: thebigG

Tasker/AudioMachine.cpp

@@ -35,7 +35,8 @@ using Engine::AudioDevice;
 using Engine::AudioMachine;
 
 /**
- * @brief AudioMachine::AudioMachine
+ * @brief AudioMachine::AudioMachine initializes the AudioDevice and all other
+ * state(such as audio formats) to enable the AudioDevice to function properly.
  */
 AudioMachine::AudioMachine() : audioDevice(nullptr), qAudioInput(nullptr) {
   QAudioFormat format;
@@ -117,7 +118,9 @@ void AudioMachine::stopRecording() {
   qAudioInput->stop();
   audioDevice->close();
 }
-bool AudioMachine::isAudioDeviceValid() {
-  audioDevice->isOpen();
-  return audioDevice->isOpen();
-}
+/**
+ * @brief AudioMachine::isAudioDeviceValid if the AudioDevice is open, then this
+ * function returns true. Otherwise, it returns false.
+ * @return
+ */
+bool AudioMachine::isAudioDeviceValid() { return audioDevice->isOpen(); }

Tasker/AudioMachine.h

@@ -10,7 +10,10 @@ class AudioMachine;
 }
 
 /**
- * @brief The Engine::AudioMachine class
+ * @brief The Engine::AudioMachine class bundles and abstracts the details of
+ * AudioDevice to make the audio device(such as built-in microphone) into a
+ * stateful machine. It also makes it easier to interface with AudioDevice by
+ * providing methods such as stopRecording().
  */
 class Engine::AudioMachine : public QObject {
   Q_OBJECT

Tasker/CommStatsQWidget.cpp

@@ -49,10 +49,6 @@ CommStatsQWidget::CommStatsQWidget(QWidget *parent)
   commitmentMetaDataText.resize(100);
   beginDateText.resize(100);
   setSelectable(true);
-  //  this->ui->GoalQLabel->setAlignment(Qt::AlignCenter);
-  //  this->la
-  //  qDebug()<<""
-  //  snapshot.setMaximumSize(600, 600);
   qDebug() << "size of snapshot=" << snapshot.size();
   qDebug() << "size polocy of snapshot" << snapshot.sizePolicy();
   //  snapshot.setMaximumHeight(400);
@@ -349,26 +345,26 @@ void CommStatsQWidget::saveCurrentSession() {
 void CommStatsQWidget::updateCommitmentInfoStatsQWidget() {
   commitmentMetaDataText.fill(' ');
   QString frequencyString{};
-  //  frequencyString.reserve(20);
-  //  frequencyString.resize(20);
-  frequencyString.append(", ");
-  frequencyString.append(QString::number(
-      User::getInstance()->getCurrentCommitment().getFrequency().frequency));
   if (User::getInstance()->getCurrentCommitment().getType() ==
       udata::CommitmentType::WEEKLY) {
+
+    frequencyString.append(", ");
+    frequencyString.append(QString::number(
+        User::getInstance()->getCurrentCommitment().getFrequency().frequency));
     frequencyString.append(" time(s) a week.");
+
+  } else if (User::getInstance()->getCurrentCommitment().getType() ==
+             udata::CommitmentType::EVERDAY) {
+    frequencyString.append(", Everyday");
+
   } else {
     // Not supported at the moment
   }
-  qDebug() << "commitmentMetaDataText before format time-->"
-           << commitmentMetaDataText;
+
   util::formatTime(
       commitmentMetaDataText,
-
       User::getInstance()->getCurrentCommitment().getFrequency().goal,
       frequencyString, 0);
-  qDebug() << "commitmentMetaDataText after format time-->"
-           << commitmentMetaDataText;
   this->ui->goalQLabel->setText(commitmentMetaDataText);
 }
 void CommStatsQWidget::updateBeginDateQLabel() {

Tasker/CommStatsQWidget.h

@@ -121,7 +121,7 @@ private slots:
   //    QVBoxLayout layout{};
   CreateCommitmentQWidget createCommimentWindow;
   NewSessionQWidget newSessionQWidget;
-  udata::CommitmentSnaphot snapshot;
+  CommitmentSnaphot snapshot;
   void updateSnapshot();
   Perf::PerfTimer newPerfTimer{};
 };

Tasker/Commitment.cpp

@@ -11,12 +11,28 @@ using namespace udata;
  * @brief Commitment::Commitment
  */
 Commitment::Commitment() {}
-
+/**
+ * @brief Commitment::Commitment Creates a new commitment. This constructor
+ * tries its best to solve any date conflicts such as dateStart being greater
+ * than dateEnd, which should not happen. It also updates all the TimeWindow
+ * objects in commitment so that the data is up to date with the current date of
+ * the machine.
+ * @param newName The name of this new commitment.
+ * @param newStart The date this commitment started. If, for whatever reason,
+ * this date happens to be earlier than the current date of the machine, then
+ * the current date is fetched from the system and this parameter is
+ * overwritten.
+ * @param newEnd The date this commitment will end, if it has an end date.
+ * @param newFrequency The object that describes the frequency of this
+ * commitment(how many times a week the user will commit to this).
+ * @param newType The type of commitment this is; WEEKLY, MONTHLY, etc.
+ * @param newNoEndDate Decides whether or not this commitment has an enddate.
+ */
 Commitment::Commitment(QString newName, QDate newStart, QDate newEnd,
-                       udata::CommitmentFrequency newInterval,
+                       udata::CommitmentFrequency newFrequency,
                        CommitmentType newType, bool newNoEndDate)
     : name{newName}, dateStart{newStart}, dateEnd{newEnd},
-      frequency{newInterval},
+      frequency{newFrequency},
       commitmentWindows{}, Type{newType}, noEndDate{newNoEndDate} {
   if (dateStart < QDate::currentDate()) {
     dateStart = QDate::currentDate();
@@ -35,15 +51,17 @@ void Commitment::setFrequency(long long newTime, int newFrequency,
 }
 void Commitment::setFrequency(CommitmentFrequency newFrequency) {
   frequency = newFrequency;
-}
+} /**
+   * @brief Commitment::setCommitmentWindows
+   * @param newCommitmentWindows
+   * @note updates commitment windows if the date between this commitment and
+   * the system are out of sync.
+   */
 void Commitment::setCommitmentWindows(
     QVector<TimeWindow> &newCommitmentWindows) {
   for (auto windows : newCommitmentWindows) {
     commitmentWindows.append(windows);
   }
-  qDebug() << "setting windows on this commitment-->"
-           << commitmentWindows.length();
-  //    commitmentWindows = newCommitmentWindows;
 }
 void Commitment::setType(CommitmentType newType) { Type = newType; }
 CommitmentType &Commitment::getType() { return Type; }
@@ -88,12 +106,16 @@ void Commitment::updateCommitmentWindows(Session newSession) {
  */
 void Commitment::updateCommitmentWindows() {
   QDate currentDate = QDate::currentDate();
+  // If the user is done with this commitment, our work is done. There is no
+  // update needed.
   if (isDone()) {
-    if (name == "Test#100") {
-      qDebug() << "Test#100 is done!";
-    }
     return;
-  } else if (commitmentWindows.isEmpty()) {
+
+  }
+  // If there are no TimeWindow objects that are part of the commitment then we
+  // are constructing this Commitment for the first time and only need a single
+  // TimeWindow.
+  else if (commitmentWindows.isEmpty()) {
     commitmentWindows.push_back(TimeWindow{});
     TimeWindow &newWindow = commitmentWindows.last();
     newWindow.startDate.setDate(currentDate.year(), currentDate.month(),
@@ -103,6 +125,8 @@ void Commitment::updateCommitmentWindows() {
                               currentDate.day());
     newWindow.frequency = frequency.frequency;
   } else {
+    // If our TimeWindow objects are up to date, then we don't need to update
+    // them :)
     TimeWindow &lastWindow = commitmentWindows.last();
     int daysSinceLastCommitmentWindow =
         lastWindow.startDate.daysTo(QDate::currentDate());
@@ -112,7 +136,11 @@ void Commitment::updateCommitmentWindows() {
 
     else if (daysSinceLastCommitmentWindow < frequency.timeWindowSize) {
       return;
-    } else if (daysSinceLastCommitmentWindow >= frequency.timeWindowSize) {
+    }
+    // Imagine we had a weekly commitment
+    // If it has been more than week since the last time we added a TimeWindow,
+    // then we might need to add 1 or more TimeWindow objects to this commitment
+    else if (daysSinceLastCommitmentWindow >= frequency.timeWindowSize) {
       int NumberOfTimeWindows =
           daysSinceLastCommitmentWindow / frequency.timeWindowSize;
       currentDate = lastWindow.endDate.addDays(1);
@@ -134,15 +162,10 @@ void Commitment::updateCommitmentWindows() {
  * updated by this function.
  */
 void Commitment::update() {
-  //  updateCommitmentWindows();
-  qDebug() << "upating-->" << name;
   if (noEndDate) {
-    qDebug() << "update on Commitment#1";
     done = false;
     return;
   }
-  qDebug() << "update on Commitment#2";
-  //           << commitmentWindows.last().endDate << "," << dateEnd;
   if (QDate::currentDate() > dateEnd) {
     done = true;
   }
@@ -165,12 +188,11 @@ void Commitment::setDone(bool newDone) { done = newDone; }
  * Meaning this function, in that case, will return true.
  *
  * @note Commitments that have noEndDate set to "true" are never considered
- * "done". In such case, this function will always return "false".
+ * "done". In such case, this function will always return false.
  * @return true if this commitment is "done". Otherwise, it returns false.
  */
 bool Commitment::isDone() {
   update();
-  qDebug() << "isDone#1";
   return done;
 }
 QVector<TimeWindow> &Commitment::getCommitmentWindows() {
@@ -214,8 +236,6 @@ QDataStream &udata::operator>>(QDataStream &in,
  */
 QDataStream &udata::operator<<(QDataStream &out,
                                const udata::Commitment &newCommitment) {
-  qDebug() << "QDataStream &udata::operator<<(QDataStream &out, const "
-              "udata::Commitment &newCommitment)";
   out << newCommitment.name << newCommitment.dateStart << newCommitment.dateEnd
       << newCommitment.frequency << newCommitment.Type
       << newCommitment.noEndDate;
@@ -262,9 +282,6 @@ QDataStream &udata::operator>>(QDataStream &in,
   in >> newDone;
 
   newCommitment.name = commitmentName;
-  if (commitmentName == "Poetry") {
-    qDebug() << "number of time windows:" << newTimeWindows.length();
-  }
   newCommitment.dateStart = commitmentDateStart;
   newCommitment.dateEnd = commitmentDateEnd;
   newCommitment.noEndDate = newNoEndDate;
@@ -285,7 +302,6 @@ QDataStream &udata::operator<<(QDataStream &out,
     out << s;
   };
   out << newTimeWindow.frequency;
-  qDebug() << "newTimeWindow startDate=*****************#2";
   return out;
 }
 QDataStream &udata::operator>>(QDataStream &in, TimeWindow &newTimeWindow) {
@@ -294,8 +310,6 @@ QDataStream &udata::operator>>(QDataStream &in, TimeWindow &newTimeWindow) {
   int TimeWindowFrequency = 0;
   in >> newStartDate >> newEndDate;
   newTimeWindow.startDate = newStartDate;
-  qDebug()
-      << "newTimeWindow startDate=*****************#1"; //<<newTimeWindow.startDate;
   newTimeWindow.endDate = newEndDate;
   int sessionCount = 0;
   in >> sessionCount;
@@ -387,8 +401,3 @@ QString Commitment::summary() const {
   return summary;
 }
 CommitmentFrequency &Commitment::getFrequency() { return frequency; }
-/**
- * @brief Commitment::setSessions
- * @param value
- */
-void Commitment::setSessions(QVector<Session> value) {}

Tasker/Commitment.h

@@ -15,25 +15,33 @@
 #include <StatsUtility.h>
 
 /**
- *@brief The udata namespace has anything related to
- * data that persistent for users such as Commitment, Task, Session etc.
+ *@brief The udata namespace has any entities related to
+ * data that is persistent for users such as Commitment, Task, Session etc. All
+ *utilities such as UdataUtils are also part of this namespace.
  */
 namespace udata {
-
 class Commitment;
 enum class CommitmentType;
 struct CommitmentFrequency;
+/**
+ * @brief The TimeWindow struct represents a span of time(such as a week) that
+ * the user has a number of tasks(defined by frequency) to complete for this
+ * partifuclar TimeWindow, whether that'd be a week or a month. startDate is the
+ * beginning of the TimeWindow, while endDate is the end of that TimeWindow(the
+ * seventh day in the case of a week.)
+ */
 struct TimeWindow {
   QDate startDate;
   QDate endDate;
   QVector<Session> sessions;
   /**
    * @brief frequency
-   * The only times the client(Commitment) should to write to this field is
-   * when creating the TimeWindow for the first time and when a TimeWindow is
+   * The only times the client(Commitment) should be able to write to this field
+   * is when creating the TimeWindow for the first time, when a TimeWindow is
    * opened (isOpen() returns true) and not done yet(isDone() returns false )
    * and the frequency changes as a result of the Commitment's frequency
-   * changing. Otherwise, frequency should not be modified.
+   * changing. This frequency may also be modified by the user when they edit a
+   * commitment .Otherwise, frequency should not be modified.
    */
   int frequency;
   /**
@@ -66,28 +74,29 @@ QDataStream &operator<<(QDataStream &out, const TimeWindow &);
 QDataStream &operator>>(QDataStream &in, TimeWindow &);
 QDataStream &operator<<(QDataStream &out, const CommitmentType &);
 QDataStream &operator>>(QDataStream &in, CommitmentType &);
+
 } // namespace udata
 
 /**
  * @brief The udata::Commitment class
  */
-enum class udata::CommitmentType { WEEKLY, MONTHLY, Custom };
+enum class udata::CommitmentType { WEEKLY, MONTHLY, EVERDAY, Custom };
 /**
- * @brief The util::CommitmentFrequency struct represents \
- * the time the user aims to spend per session(time) on each commitment \
+ * @brief The util::CommitmentFrequency struct represents
+ * the time the user aims to spend per session(time) on each commitment
  * AND how often they intend to spend that amount of time on each specific
- *Task/Session of \ the commitment.
- *@note Beware that this struct DOES NOT strictly \
- * "define" whether the user has completed a "session" \
- * withtin a certain TimeWindow. \
+ *Task/Session of the commitment.
+ *@note Beware that this struct DOES NOT strictly
+ * "define" whether the user has completed a "session"
+ * withtin a certain TimeWindow.
  *For example; suppose Alice commits to write 30 minutes everyday.
  * In that case the struct would look like this
  * struct util:CommitmentFrequency
  * {
  * time = 1800 //30 minutes in seconds
  * frequency = 1;
  * timeWindowSize  = 1;
- *  //The frequency variable  represents how many times and the timeWindowSize\
+ *  //The frequency variable  represents how many times and the timeWindowSize
  * variable represents the size of the time
  * }
  * In the case of twice a week:
@@ -101,11 +110,11 @@ enum class udata::CommitmentType { WEEKLY, MONTHLY, Custom };
  *there will 7 sessions. It just means that was Alice's optimal goal, and this
  *can be displayed in the
  * viewer(UI) as one sees fit. There could very much be the case where Alice
- *decides \
+ *decides
  * to do 14 sessions of 15 minutes(14x15=30x7). A TimeWindow(in the case of
- *Alice a week) is \
+ *Alice a week) is
  * is only considered accomplished(or closed if you will) when the total amount
- *of \ time(in this case 210 minutes) is reached. Tasker should encourage the
+ *of time(in this case 210 minutes) is reached. Tasker should encourage the
  *user to commit to Frequency number of sessions per week(TimeWindow), BUT the
  *user may choose to "split" that time during the week into as many sessions as
  *they see fit. Hopefully that makes sense. This struct, being a simple struct,
@@ -186,6 +195,7 @@ class udata::Commitment {
   CommitmentType Type;
   bool noEndDate;
   bool done = false;
+
   void update(); // helper function for isDone()
 
 public:
@@ -197,15 +207,13 @@ class udata::Commitment {
   QDate &getDateEnd();
   void setDateEnd(QDate value);
   QVector<Session> getAllSessions();
-  void setSessions(QVector<udata::Session> value);
   void setName(QString);
   const QString &getName() const;
   void setType(CommitmentType);
   CommitmentType &getType();
   QString summary() const;
   void updateCommitmentWindows(Session);
   void updateCommitmentWindows();
-
   bool isDone();
   void setDone(bool);
   void setFrequency(long long newTime, int newFrequency, int newTimeWinowSize);