libprompt.py

#####################################################################################
###
### Acme Software Works, Inc.
###
### Created June 16, 2019 by Don Dugger
###
### <PRE>
### Copyright 2019 Acme Software Works, Inc.
### 
### Redistribution and use in source and binary forms, with or without
### modification, are permitted provided that the following conditions are met:
### 
### 1. Redistributions of source code must retain the above copyright notice,
###    this list of conditions and the following disclaimer.
### 
### 2. Redistributions in binary form must reproduce the above copyright notice,
###    this list of conditions and the following disclaimer in the documentation
###    and/or other materials provided with the distribution.
### 
### THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
### AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
### IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
### ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
### LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
### CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
### GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
### HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
### LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
### OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
### <PRE>
#####################################################################################
import calendar
from datetime import datetime
import subprocess

######### Configuration ##################
# Make changes as needed

# Database configuration
config = {
  'user': 'username',
  'password': 'password',
  'host': '127.0.0.1',
  'database': 'taskprompt',
  'raise_on_warnings': True
}

# Location configuration
BIN_DIR = "/home/username/bin/"
UI_DIR = "/home/username/bin/"
SPEAK = "/usr/local/bin/flite"
PROMPT_DATE_FORMAT = "%A %B %e, %Y  %I:%M %p"

######### End of Configuration #############

######### General functions ################

#############################################
# Speak the text.
# The path to 'flite' or the speaking program may need
# to be changed.
def sayit(text):
    args = [SPEAK,'-t "{}"'.format(text)]
    res = subprocess.run(args)

###########################################################
# Calculate the nth weekday of the month given the date and
# the 'month modifier spec'. Which is the numeric operator
# followed by the three character weekday abbreviation. 
def monthDay(the_date, spec):
    # Pull the year and month out of the
    # datetime object as integers.
    year = int(the_date.strftime("%Y"))
    month = int(the_date.strftime("%m"))
    # The last 3 character of the spec are the weekday
    # and the list we get from the calendar object will
    # have the first character the weekday capitalized.
    # The rest the spec is the numeric operator. We will
    # change it to lower case so that the spec is case
    # insensitive.
    weekday = spec[-3:].lower().capitalize()
    nth_day = spec[:-3].lower()
    # Now because 'LastDay' is a special case we get
    # done with it.
    if weekday == "Day" and nth_day == "last":
        first_last = calendar.monthrange(year,month)
        return first_last[1]
    # Get the list of abbreviated weekday names. 
    DAY_NAMES = [day for day in calendar.day_abbr]
    # Get the index used by the calendar object for
    # the day that is in the spec.
    day_index = DAY_NAMES.index(weekday)
    # Then find it in the calendar ( A little magic )
    # If you print out what the 'calendar' object returns
    # from the 'monthcalendar' method this will make more
    # sense.
    possible_dates = [
            week[day_index]
            for week in calendar.monthcalendar(year, month)
                if week[day_index]] # remove zeroes
    # Then finally translate the numeric operator. 
    if   nth_day == 'last':
        day_index = -1
    elif nth_day == 'first':
        day_index = 0 
    elif nth_day == 'second':
        day_index = 1 
    elif nth_day == 'third':
        day_index = 2 
    elif nth_day == 'fourth':
        day_index = 3 
    return possible_dates[day_index]

                    

cronprompt.py

This script is called by cron every 15 minutes. It check to see if a prompt is due and if it is it executes a text to speech program saying "A task is due" then calls the prompt.php script.

#!/usr/local/bin/python3.6
#####################################################################################
###
### Acme Software Works, Inc.
###
### Created June 16, 2019 by Don Dugger
###
### <PRE>
### Copyright 2019 Acme Software Works, Inc.
### 
### Redistribution and use in source and binary forms, with or without
### modification, are permitted provided that the following conditions are met:
### 
### 1. Redistributions of source code must retain the above copyright notice,
###    this list of conditions and the following disclaimer.
### 
### 2. Redistributions in binary form must reproduce the above copyright notice,
###    this list of conditions and the following disclaimer in the documentation
###    and/or other materials provided with the distribution.
### 
### THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
### AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
### IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
### ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
### LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
### CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
### GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
### HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
### LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
### OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
### <PRE>
#####################################################################################
from datetime import datetime
from dateutil.relativedelta import relativedelta
from promptdb import PromptDB
from libprompt import BIN_DIR
from libprompt import sayit
import sys
import subprocess


##################### Main ###############################
#
# This program is a single loop which goes through all the
# prompts in the database and if they are due, says so and
# then executes the 'prompt' program.
#

db = PromptDB()
# Get the list of prompts.
prompt_list = db.fetchAllPrompts()
for prompt in prompt_list:
    # Get the due date and time of the task
    prompt_datetime = datetime.strptime(str(prompt[1]) + " " + str(prompt[2]),"%Y-%m-%d %H:%M:%S")
    # Move a head 5 minutes so the prompt happens just before the time setting 
    now = datetime.today() + relativedelta(minutes=+6)
    if now > prompt_datetime: # Is the task due?
        # Say so
        sayit("A task is due")
        # Display the task prompt
        id_str = '-i{}'.format(prompt[0])
        args = [BIN_DIR+'prompt.py',id_str]
        res = subprocess.run(args)

                    

prompt.py

#!/usr/local/bin/python3.6
#####################################################################################
###
### Acme Software Works, Inc.
###
### Created June 16, 2019 by Don Dugger
###
### <PRE>
### Copyright 2019 Acme Software Works, Inc.
### 
### Redistribution and use in source and binary forms, with or without
### modification, are permitted provided that the following conditions are met:
### 
### 1. Redistributions of source code must retain the above copyright notice,
###    this list of conditions and the following disclaimer.
### 
### 2. Redistributions in binary form must reproduce the above copyright notice,
###    this list of conditions and the following disclaimer in the documentation
###    and/or other materials provided with the distribution.
### 
### THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
### AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
### IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
### ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
### LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
### CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
### GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
### HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
### LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
### OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
### <PRE>
#####################################################################################
from PyQt5 import QtWidgets, uic, QtCore, QtGui
import time
from time import gmtime, strftime
from threading import Timer
from datetime import datetime
from dateutil.relativedelta import relativedelta
import getopt, sys, os
from promptdb import PromptDB
from promptdialog import PromptDialog
from libprompt import monthDay
from libprompt import UI_DIR
from libprompt import PROMPT_DATE_FORMAT
import re


#####################################################################################

def usage():
    print("Usage: {} <-i id (prompt db id)>".format(os.path.basename(sys.argv[0])))

#####################################################################################
#
# The class Main is the program. The functional part that is outside Main is getting
# the command line option. 
#
class Main(QtWidgets.QMainWindow):
    def __init__(self):
        super(Main, self).__init__()
        uic.loadUi(UI_DIR + 'prompt.ui', self)

        # Get the prompt dialog box for editing.
        self.dlg = PromptDialog()

        # Retrieve and display the date, time and task text.
        self.db = PromptDB()
        self.prompt = self.db.fetchOnePrompt(prompt_id)
        self.prompt_datetime = datetime.strptime(str(self.prompt[1]) + " " + str(self.prompt[2]),"%Y-%m-%d %H:%M:%S")
        self.dateText.setText(self.prompt_datetime.strftime(PROMPT_DATE_FORMAT))
        self.taskText.setText(self.prompt[4])

        # Connect the 'Later' button to exit() and make it
        # the default. Making it the fault is so the user
        # doesn't accidentally mark the task complete.
        self.laterButton.clicked.connect(exit)
        self.laterButton.setAutoDefault(True)
        # Connect the rest of the buttons to there respective methods. 
        self.editButton.clicked.connect(self._edit)
        self.completeButton.clicked.connect(self._complete)

        # The prompt has a 3 minute time out so that
        # prompt don't accumulate on the user's screen.
        # The time has a progress bar to show the user how much
        # time is left. 
        self.show()
        self.clock = 180 # 3 Minutes
        self.timer = QtCore.QTimer(self)
        self.timer.timeout.connect(self._tic)
        self.timer.start(3000)

    # The progress bar is updated every 3 seconds.
    def _tic(self):
        if self.clock > 0:
            self.clock -= 3
            self.progressBar.setValue(self.clock)
        else:
            exit(0)

    # To edit just load the prompt dialog box with the info that was fetched by the constructor.
    def _edit(self):
        # First change the time from 24 hour to 12 hour plus the period (AM/PM).
        prompt_time = datetime.strptime(str(self.prompt[2]),"%H:%M:%S")
        # Then display the prompt dialog box.
        self.dlg.edit(prompt_id,self.prompt[1].strftime("%Y-%m-%d"),prompt_time.strftime("%I:%M %p"),self.prompt[3],self.prompt[4])

    # When a task is complete it's entree in the database needs to be updated. If the frequency is 'Once' the record will be
    # deleted otherwise the due date will be updated in accordance with the frequency spec.
    # Note that the frequency spec was validated upon the tasks entree and will not be re-validated here.
    def _complete(self):
        # First break a part the frequency spec.
        freq_list = re.split(',',self.prompt[3])
        x = 1 # If there is no multiplier the frequency is once.
        mult_list = re.split('\*',freq_list[0])
        if len(mult_list) > 1: # Is there a multiplier?
            # The second item in the list is the multiplier.
            x = int(mult_list[1])
        # Deal with limits
        count = int(self.prompt[5])
        # Note if the count starts at 0 the count is not active.
        if count: # Is this task being counted down?
            count -= 1
            if count == 0: # If it's finished delete it.
                self.db.delPrompt(prompt_id)
            else: # Update the database record.
                self.db.setCount(prompt_id,count)
        # Now process main frequency spec
        if re.match("once$",freq_list[0],re.IGNORECASE): # Delete & exit.
            self.db.delPrompt(prompt_id)
            exit(0)
        elif re.match("daily($|\*[0-9]+$)",freq_list[0],re.IGNORECASE): # Update to days times x.
            self.prompt_datetime += relativedelta(days=+x)
        elif re.match("weekly($|\*[0-9]+$)",freq_list[0],re.IGNORECASE): # Update to weeks times x.
            self.prompt_datetime += relativedelta(weeks=+x)
        elif re.match("monthly($|\*[0-9]+$)",freq_list[0],re.IGNORECASE): # Update to months times x.
            # If there is a modifier and it not the limit modifier update accordingly.
            if len(freq_list) > 1 and not re.match("limit=[0-9]+$",freq_list[1],re.IGNORECASE):
                # Get the day from the prompt.
                day = int(self.prompt_datetime.strftime("%e"))
                # Move forward x months.
                self.prompt_datetime += relativedelta(months=+x)
                # Get the day of the month-day spec.
                the_day = monthDay(self.prompt_datetime,freq_list[1])
                # Calculate the proper new day.
                self.prompt_datetime += relativedelta(days=+(the_day-day))
            else: # If there is no modifier simply move ahead x months.
                self.prompt_datetime += relativedelta(months=+x)
        elif re.match("yearly($|\*[0-9]+$)",freq_list[0],re.IGNORECASE): # Update to years times x.
            self.prompt_datetime += relativedelta(years=+x)
        self.db.setDate(prompt_id,self.prompt_datetime.strftime("%Y-%m-%d"))
        exit(0)

#####################################################################################
################ Main ###############################################################
#####################################################################################
# The propmpt.py program displays the 'task' that is due. 
# It requires the database id in order to retrieve the 'task' information.
# It does not determine if the 'task' is due it simply displays it. It will
# update completed 'tasks'.
#
# Start by checking that the id has been entered correctly.
try:
    opts, args = getopt.getopt(sys.argv[1:], "i:")
except getopt.GetoptError as err:
    print(str(err))
    usage()
    sys.exit(2)

# The id is needed globally.
global prompt_id 
prompt_id = -1 # Set it to a invalid value to test later.
for opt, arg in opts:
    if opt == "-i":
        prompt_id = int(arg)
    else:
        usage()
        sys.exit(2)

if prompt_id < 0: # Was a valid value entered?
    usage()
    sys.exit(0)

# Start everything up.
app = QtWidgets.QApplication(sys.argv)
window = Main()
sys.exit(app.exec())

            
                    

promptdialog.py

#####################################################################################
###
### Acme Software Works, Inc.
###
### Created June 16, 2019 by Don Dugger
###
### <PRE>
### Copyright 2019 Acme Software Works, Inc.
### 
### Redistribution and use in source and binary forms, with or without
### modification, are permitted provided that the following conditions are met:
### 
### 1. Redistributions of source code must retain the above copyright notice,
###    this list of conditions and the following disclaimer.
### 
### 2. Redistributions in binary form must reproduce the above copyright notice,
###    this list of conditions and the following disclaimer in the documentation
###    and/or other materials provided with the distribution.
### 
### THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
### AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
### IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
### ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
### LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
### CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
### GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
### HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
### LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
### OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
### <PRE>
#####################################################################################
from PyQt5 import QtWidgets, uic, QtCore, QtGui
from PyQt5.QtCore import QDate, QTime, QDateTime, Qt, QRect, QPoint
from PyQt5.QtWidgets import QMessageBox
from datetime import datetime
from dateutil.relativedelta import relativedelta
import getopt, sys
from promptdb import PromptDB
from libprompt import monthDay
from libprompt import UI_DIR
import re

#####################################################################################
# The Frequency Combo Box.
# This is one of the primary features of 'TaskPrompt'.
# The FreqBox is a separate class (object) in order to
# validate the frequency specification during entree.
# By deriving it from the base class QComboBox. The 
# method 'focusOutEvent()' can be replaced so the frequency
# specification can immediately validated. 
class FreqBox(QtWidgets.QComboBox):
    def __init__(self,parent,x,y): # Let the caller set the position. 
        super(FreqBox, self).__init__(parent)
        self.setGeometry(QRect(x,y,250,30))
        # Generally set up the appearance. 
        font = QtGui.QFont()
        font.setFamily("Sans Serif")
        font.setPointSize(11)
        font.setItalic(False)
        self.setFont(font)
        self.setFocusPolicy(Qt.StrongFocus)
        # Load the basic frequencies.
        freq_list = [
            'Once',
            'Daily',
            'Weekly',
            'Monthly',
            'Yearly',
            ]
        self.clear()
        self.addItems(freq_list)
        # It is editable so modifier can be added.
        self.setEditable(True)

        self.show()

    # Validate the specification.
    def isFreqValid(self):
        freq_list = re.split(',',self.currentText())
        # The first argument is the frequency.
        if not re.match("once$|daily($|\*[0-9]+$)|weekly($|\*[0-9]+$)|monthly($|\*[0-9]+$)|yearly($|\*[0-9]+$)",freq_list[0],re.IGNORECASE):
            msg = QMessageBox()
            msg.setIcon(QMessageBox.Critical)
            msg.setText("Incorrect frequency specification!")
            msg.exec()
            return False
        # The second modifiers can be a day modifier or a limit modifier.
        if len(freq_list) > 1:
            if not (re.match("monthly",freq_list[0],re.IGNORECASE)\
               and re.match(".+sun$|.+mon$|.+tue$|.+wed$|.+thu$|.+fri$|.+sat$|.+day$",freq_list[1],re.IGNORECASE)\
               and re.match("^first...$|^second...$|^third...$|^fourth...$|last...$",freq_list[1],re.IGNORECASE)\
               or re.match("limit=[0-9]+$",freq_list[1],re.IGNORECASE)):
                msg = QMessageBox()
                msg.setIcon(QMessageBox.Critical)
                msg.setText("Incorrect frequency modifier specification!")
                msg.exec()
                return False
        # The third modifier can only be a limit modifier.
        if len(freq_list) > 2:
            if not re.match("limit=[0-9]+$",freq_list[2],re.IGNORECASE):
                msg = QMessageBox()
                msg.setIcon(QMessageBox.Critical)
                msg.setText("Incorrect number modifiers!")
                msg.exec()
                return False
        # Number is 1 frequency 1 day modifiers plus a limit modifier for a total of 3.
        if len(freq_list) > 3:
            msg = QMessageBox()
            msg.setIcon(QMessageBox.Critical)
            msg.setText("Incorrect number modifiers!")
            msg.exec()
            return False
        return True

    # This replaces the base class method so the focus
    # event will come here. And when the focus is lost
    # it is validated.
    def focusOutEvent(self, event):
        if event.lostFocus():
            self.isFreqValid()
        # Now let the base class have the event.
        super(FreqBox, self).focusOutEvent(event)
        

#####################################################################################
# The Prompt Dialog Box
#
# This dialog box is used for adding and editing prompts.
#
class PromptDialog(QtWidgets.QDialog):
    def __init__(self):
        super(PromptDialog, self).__init__()
        # Setup the Prompt entry/edit dialog box
        uic.loadUi(UI_DIR + 'taskprompt-input.ui',self)
        self.datepicker = uic.loadUi(UI_DIR + 'datepicker.ui')
        self.help = uic.loadUi(UI_DIR + 'prompthelp.ui')

        # Setup the 'datepicker'.
        self.datepicker.calendar.activated.connect(self._updateDate)
        self.datepicker.buttonBox.accepted.connect(self._updateDateOK)
        self.datepicker.buttonBox.rejected.connect(self.datepicker.close)
        self.datepicker.todayButton.clicked.connect(self.setToday)
        self.dateButton.clicked.connect(self.datepicker.exec)
        # Connect the help screen.
        self.buttonBox.helpRequested.connect(self.help.exec)
        self.help.buttonBox.accepted.connect(self.help.close)
        # Init strings for edit change test.
        self.date_str = ""
        self.time_str = ""
        self.freq_str = ""

        # The time combo box.
        # The list of times.
        time_list = [
            '12:00 AM', '12:15 AM', '12:30 AM', '12:45 AM', '01:00 AM', '01:15 AM', '01:30 AM', '01:45 AM',
            '02:00 AM', '02:15 AM', '02:30 AM', '02:45 AM', '03:00 AM', '03:15 AM', '03:30 AM', '03:45 AM',
            '04:00 AM', '04:15 AM', '04:30 AM', '04:45 AM', '05:00 AM', '05:15 AM', '05:30 AM', '05:45 AM',
            '06:00 AM', '06:15 AM', '06:30 AM', '06:45 AM', '07:00 AM', '07:15 AM', '07:30 AM', '07:45 AM',
            '08:00 AM', '08:15 AM', '08:30 AM', '08:45 AM', '09:00 AM', '09:15 AM', '09:30 AM', '09:45 AM',
            '10:00 AM', '10:15 AM', '10:30 AM', '10:45 AM', '11:00 AM', '11:15 AM', '11:30 AM', '11:45 AM',
            '12:00 PM', '12:15 PM', '12:30 PM', '12:45 PM', '01:00 PM', '01:15 PM', '01:30 PM', '01:45 PM',
            '02:00 PM', '02:15 PM', '02:30 PM', '02:45 PM', '03:00 PM', '03:15 PM', '03:30 PM', '03:45 PM',
            '04:00 PM', '04:15 PM', '04:30 PM', '04:45 PM', '05:00 PM', '05:15 PM', '05:30 PM', '05:45 PM',
            '06:00 PM', '06:15 PM', '06:30 PM', '06:45 PM', '07:00 PM', '07:15 PM', '07:30 PM', '07:45 PM',
            '08:00 PM', '08:15 PM', '08:30 PM', '08:45 PM', '09:00 PM', '09:15 PM', '09:30 PM', '09:45 PM',
            '10:00 PM', '10:15 PM', '10:30 PM', '10:45 PM', '11:00 PM', '11:15 PM', '11:30 PM', '11:45 PM',
            ]
        # Clear and initialize the time combo box.
        self.timeBox.clear()
        self.timeBox.addItems(time_list)
        # Force the 'timeBox' to obey the drop down limit (maxVisibleItems).
        # When 'QComboBox'es are set to not editable it is ignored. 
        self.timeBox.setStyleSheet("QComboBox { combobox-popup: 0; }");

        # In order to put the 'FreqBox' in a place
        # based on the layout produced by Qt Designer
        # it is placed in reference to the frequency 
        # label 'label_freq'.
        x = self.label_freq.pos().x()
        y = self.label_freq.pos().y()
        w = self.label_freq.size().width()
        # Put 'freqBox' behind the label plus 10.
        self.freqBox = FreqBox(self,x+w+10,y)
        self.buttonBox.accepted.connect(self._doAccept)
        # With the 'freqBox' being setup programmatically
        # the tab order will need to set.
        self.setTabOrder(self.dateBox,self.dateButton)
        self.setTabOrder(self.dateButton,self.timeBox)
        self.setTabOrder(self.timeBox,self.freqBox)
        self.setTabOrder(self.freqBox,self.taskText)
        # Initialize the edit mode state machine.
        self.state = None
        self.EDIT = 1
        self.ADD = 2
        # Set the add id to unknown.
        self.add_id = -1

    # Setting the date picker to today's date. This implements the
    # 'datepicker's 'Today' button. 
    def setToday(self):
        self.datepicker.calendar.setSelectedDate(QDate.currentDate())

    # When the accept ( The "OK" button ) is received determine
    # which mode the dialog box was started in.
    def _doAccept(self):
        if self.state == self.EDIT:
            self._acceptEdit()
        elif self.state == self.ADD:
            self._acceptAdd()
        self.close()

    # When a date is chosen in the 'calendar' object
    # of the 'datepicker' update the 'dateBox' text.
    def _updateDate(self, date):
        self.dateBox.setText(date.toString("yyyy-MM-dd"))
        self.datepicker.close()

    # When a date is chosen in the 'datapicker' it is 
    # validated and the 'dateBox' text is updated.
    def _updateDateOK(self):
        date = self.datepicker.calendar.selectedDate()
        self.dateBox.setText(date.toString("yyyy-MM-dd"))
        now = datetime.now()
        if now >= self._getDateTime():
            msg = QMessageBox()
            msg.setIcon(QMessageBox.Critical)
            msg.setText("The date must be in the future")
            msg.exec()
            return
        self._updateDate(date)

    # With the dialog box's 'dateBox' and 'timeBox' retrive them
    # convert to a 'datetime' object and return it.
    def _getDateTime(self):
        # Retrieve the date which is a string. 
        date_str = self.dateBox.text()
        # Split into year, month and day strings which
        # can the be converted to integers.
        date_list = date_str.split('-')
        # The time is in a 12 hour format it needs
        # to be in a 24 hour format.
        time_str = self.timeBox.currentText()
        # Split it up into hours, minutes and period (AM/PM).
        time_list1 = time_str.split(' ')
        time_list2 = time_list1[0].split(':')
        # Convert hours and minutes string to integers.
        hr = int(time_list2[0])
        mn = int(time_list2[1])
        # Now deal with period.
        if hr == 12 and time_list1[1] == "AM":
            hr = 0
        elif time_list1[1] == "PM" and hr != 12:
            hr += 12
        # Return the 'datetime' object.
        return datetime(int(date_list[0]),int(date_list[1]),int(date_list[2]),hr,mn,0)

    # When in ADD mode and the 'OK' button is pressed
    # this is the method that is invoked.
    def _acceptAdd(self):
        # Retrieve the date and time.
        the_date = self._getDateTime()
        now = datetime.now()
        # Make sure the date be entered is in the future.
        if now > the_date:
            msg = QMessageBox()
            msg.setIcon(QMessageBox.Critical)
            msg.setText("The date must be in the future")
            msg.exec()
            return
        # Get a database connection.
        db = PromptDB()
        # If no limit is set the count is initialized to zero.
        count = 0
        # If 'Monthly' is set check for modifiers.
        if re.match("monthly",self.freqBox.currentText(),re.IGNORECASE):
            freq_str = self.freqBox.currentText()
            freq_list = freq_str.split(',')
            # If the first modifier is not a 'limit' modifier it's 
            # a day of the month modifier. 
            # Note that frequency specification has already been validated.
            if not re.match("limit=[0-9]+",freq_list[1],re.IGNORECASE):
                # The start date will now be set to the first due date.
                # First get the modified day of the month.
                the_day = monthDay(the_date,freq_list[1])
                # The day entered.
                day = int(the_date.strftime("%e"))
                # Adjust the 'datetime' object to the due date.
                if the_day <= day:
                    the_date += relativedelta(months=+1)
                    the_day = monthDay(the_date,freq_list[1])
                the_date += relativedelta(days=+(the_day-day))
        # Has a limit been set.
        if re.match(".+limit=[0-9]+$",self.freqBox.currentText(),re.IGNORECASE):
            freq_list = self.freqBox.currentText().split('=')
            count = int(freq_list[1]) # Set the count.
        # Add the new prompt to the database and set the add id so the caller can retrieve it.
        self.add_id = db.addPrompt(the_date.strftime("%Y-%m-%d"),
                                   the_date.strftime("%H:%M:%S"),
                                   self.freqBox.currentText(),
                                   self.taskText.text(),
                                   count)

    # When in EDIT mode and the 'OK' button is pressed
    # this is the method that is invoked.
    def _acceptEdit(self):
        # Retrieve the dialog box's entrees.
        the_date = self._getDateTime()
        date_str = the_date.strftime("%Y-%m-%d")
        time_str = the_date.strftime("%H:%M:%S")
        freq_str = self.freqBox.currentText()
        # Get a database connection.
        db = PromptDB()
        # Initialize the count variable. 
        count = 0
        # If the date or time have been changed check that it is in the future.
        if self.date_str != date_str or self.time_str != time_str:
            now = datetime.now()
            if now > the_date:
                msg = QMessageBox()
                msg.setIcon(QMessageBox.Critical)
                msg.setText("The date must be in the future")
                msg.exec()
                return
        # If the frequency spec has changed deal with it.
        if self.freq_str != freq_str:
            # If the frequency is monthly check for modifiers.
            if re.match("monthly",self.freqBox.currentText(),re.IGNORECASE):
                freq_str = self.freqBox.currentText()
                freq_list = freq_str.split(',')
                # If the modifier is not a limit update the due date
                if not re.match("limit=[0-9]+",freq_list[1],re.IGNORECASE):
                    the_day = monthDay(the_date,freq_list[1])
                    day = int(the_date.strftime("%e"))
                    if the_day <= day:
                        the_date += relativedelta(months=+1)
                        the_day = monthDay(the_date,freq_list[1])
                    the_date += relativedelta(days=+(the_day-day))
            # There is limit modifiers update the count.
            if re.match(".+limit=[0-9]+$",self.freqBox.currentText(),re.IGNORECASE):
                freq_list = self.freqBox.currentText().split('=')
                count = int(freq_list[1])
            db.setCount(self.current_id,count)
        # Update the database.
        db.editPrompt(self.current_id,
                      date_str,
                      time_str,
                      freq_str,
                      self.taskText.text())


    # Caller's access to id of the added prompts.
    def getAddId(self):
        return self.add_id

    # This is the caller's access to the edit functionality.
    def edit(self,this_id,date_str,time_str,freq_str,task_str):
        # Save the starting values so changes can be detacted.
        self.date_str = date_str
        self.time_str = time_str
        self.freq_str = freq_str
        # Set the date picker to the date of the prompt.
        # Note Qt has a different date class used in the 'calendar' object.
        date_list = date_str.split('-')
        self.datepicker.calendar.setSelectedDate(QDate(int(date_list[0]),int(date_list[1]),int(date_list[2])))
        self.dateBox.setText(date_str) # The text is just a string
        # Set the time to the time in the prompt
        index = self.timeBox.findText(time_str)
        self.timeBox.setCurrentIndex(index)
        # Set the frequency to the frequency in the prompt
        index = self.freqBox.findText(freq_str)
        if index >= 0:
            self.freqBox.setCurrentIndex(index)
        else:
            self.freqBox.addItem(freq_str)
            index = self.freqBox.count()-1
            self.freqBox.setCurrentIndex(index)
        self.taskText.setText(task_str)
        # Change the return to edit
        self.current_id = this_id
        self.state = self.EDIT
        self.exec()

    # This is the caller's access to the add functionality.
    def add(self):
        today = datetime.today()
        # Calculate the next 15 minute segment
        index = int(today.strftime("%H"))*60
        index += int(today.strftime("%M"))
        index = (index/15)+1
        self.timeBox.setCurrentIndex(index)
        # Set the date picker to today
        self.datepicker.calendar.setSelectedDate(QDate.currentDate())
        self.dateBox.setText(today.strftime("%Y-%m-%d"))
        # Set the frequency to "Once"
        self.freqBox.setCurrentIndex(0)
        self.taskText.clear()
        # Change the return to add
        self.state = self.ADD
        self.exec()

                    

qtlistprompts.py

#!/usr/local/bin/python3.6
#####################################################################################
###
### Acme Software Works, Inc.
###
### Created June 16, 2019 by Don Dugger
###
### <PRE>
### Copyright 2019 Acme Software Works, Inc.
### 
### Redistribution and use in source and binary forms, with or without
### modification, are permitted provided that the following conditions are met:
### 
### 1. Redistributions of source code must retain the above copyright notice,
###    this list of conditions and the following disclaimer.
### 
### 2. Redistributions in binary form must reproduce the above copyright notice,
###    this list of conditions and the following disclaimer in the documentation
###    and/or other materials provided with the distribution.
### 
### THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
### AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
### IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
### ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
### LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
### CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
### GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
### HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
### LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
### OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
### <PRE>
#####################################################################################
from PyQt5 import QtWidgets, uic, QtCore, QtGui
from PyQt5.QtCore import QDate, QTime, QDateTime, Qt
from PyQt5.QtWidgets import QInputDialog,\
                            QLineEdit,\
                            QLabel,\
                            QProgressDialog,\
                            QWidget,\
                            QTableWidgetItem,\
                            QTableWidgetSelectionRange,\
                            QMessageBox
from datetime import datetime
from threading import Timer
from promptdb import PromptDB
from promptdialog import PromptDialog
from libprompt import BIN_DIR
import sys
import subprocess

#####################################################################################
#
# This is the prime user interface to the 'TasksPrompt' system.
#
# It list all pending tasks and allows the user to add, delete and edit them as well
# as checking for currently due ones.
#
class Main(QtWidgets.QMainWindow):
    def __init__(self):
        super(Main, self).__init__()
        uic.loadUi('taskprompt-main.ui', self)
        self.dlg = PromptDialog()

        # Connect the Buttons
        self.quitButton.clicked.connect(self._quit)
        self.quitButton.setAutoDefault(True)
        self.editButton.clicked.connect(self._edit)
        self.deleteButton.clicked.connect(self._delete)
        self.addButton.clicked.connect(self._add)
        self.updateButton.clicked.connect(self._update)

        # Set the column Headers.
        self.promptTable.setHorizontalHeaderLabels(['','Date','Time','Frequency','CT','Task'])
        # Set column widths.
        self.promptTable.setRowHidden(0,True)
        self.promptTable.setColumnWidth(0,0)
        self.promptTable.setColumnWidth(1,90)
        self.promptTable.setColumnWidth(2,80)
        self.promptTable.setColumnWidth(3,185)
        self.promptTable.setColumnWidth(4,25)
        # Set full row selection.
        col_ct = self.promptTable.columnCount()
        self.promptTable.setRangeSelected(QTableWidgetSelectionRange(0, col_ct-1, 0, 1), True)
        # Get the tasks from the datadase.
        self.db = PromptDB()
        self.loadTable()
        # Show the window.
        self.show()
        # Now setup a one minute timer to
        # update prompts that may have changed 
        self.timer = QtCore.QTimer(self)
        self.timer.timeout.connect(self._tic)
        self.timer.start(60000)

    # The timer
    def _tic(self):
        # Update the list
        row = self.promptTable.currentRow()
        self.loadTable()
        self.promptTable.selectRow(row)

    # Connect to the 'Quit' button.
    def _quit(self):
        exit(0)

    # Update the prompt list.
    def loadTable(self):
        # get a fresh connection
        self.db.close()
        self.db.setup()
        # Get the list from the database.
        prompt_list = self.db.fetchAllPrompts()
        self.db.close()
        # Clear the list before re-populating it.
        while self.promptTable.rowCount() > 0:
            self.promptTable.removeRow(0)
        # Go through the list a row at a time.
        for row in prompt_list:
            # If the count (6th column) is zero do not display it.
            count = int(row[5])
            if int(row[5]) > 0:
                count_str = str(count)
            else:
                count_str = ""
            # The time needs to be converted from 24 clock to 12 hr plus the period (AM/PM).
            x = datetime.strptime(str(row[2]), '%H:%M:%S')
            # Get the position into which to place the next row, at the end of the list.
            rowPosition = self.promptTable.rowCount()
            self.promptTable.insertRow(rowPosition)
            # Populate it.
            self.promptTable.setItem(rowPosition , 0, QTableWidgetItem(str(row[0])))
            self.promptTable.setItem(rowPosition , 1, QTableWidgetItem(row[1].strftime("%Y-%m-%d")))
            self.promptTable.setItem(rowPosition , 2, QTableWidgetItem(x.strftime("%I:%M %p")))
            self.promptTable.setItem(rowPosition , 3, QTableWidgetItem(row[3]))
            self.promptTable.setItem(rowPosition , 4, QTableWidgetItem(count_str))
            self.promptTable.setItem(rowPosition , 5, QTableWidgetItem(row[4]))
        # Place the selection at the top.
        self.promptTable.clearSelection()
        self.promptTable.selectRow(0)

    # Connected to the 'Edit' button.
    # Load the dialog box with the selected prompt and display it.
    def _edit(self):
        # Get the selected row.
        row = self.promptTable.currentRow()
        # Get the database id.
        id = self.promptTable.item(row, 0).text()
        # Get the prompt data as strings.
        date_str = self.promptTable.item(row, 1).text()
        time_str = self.promptTable.item(row, 2).text()
        freq_str = self.promptTable.item(row, 3).text()
        task_str = self.promptTable.item(row, 5).text()
        # Hand the dialog box the data. The dialog class will
        # handle verifying and entering the changes in the database.
        self.dlg.edit(id,date_str,time_str,freq_str,task_str)
        # Now update the list.
        self.loadTable()
        # Put the selection back to where it was.
        self.promptTable.selectRow(row)

    # Connected to the 'Delete' button.
    # Delete the prompt from the database and the displayed list.
    def _delete(self):
        # Get the selected prompt.
        row = self.promptTable.currentRow()
        # get a fresh connection
        self.db.close()
        self.db.setup()
        # Delete it from the database.
        self.db.delPrompt(self.promptTable.item(row, 0).text())
        self.db.close()
        # Set the selection near where it was.
        self.promptTable.selectRow(row)
        # And remove it from the list.
        self.promptTable.removeRow(row)

    # Connected to the 'Add' button.
    def _add(self):
        # Display a blank dialog box.
        self.dlg.add()
        # Get the database id of the last entree.
        prompt_id = self.dlg.getAddId()
        # Re-load the list.
        self.loadTable()
        # Find the new prompt if there is one and select it.
        for row in range(self.promptTable.rowCount()):
            if int(self.promptTable.item(row,0).text()) == prompt_id:
                self.promptTable.selectRow(row)

    # Connected to the 'Update' button.
    # This call the same program the cron does. It allows
    # the user to check for due tasks between cron checks.
    def _update(self):
        # Get the current selection so it can be re-display afterwards.
        row = self.promptTable.currentRow()
        # Set the command.
        args = [BIN_DIR+'cronprompt.py']
        # Execute it.
        res = subprocess.run(args, stdout=subprocess.PIPE)
        # Update the list.
        self.loadTable()
        self.promptTable.selectRow(row)

################ Main ######################################################################

app = QtWidgets.QApplication(sys.argv)
window = Main()
sys.exit(app.exec())

                    

promptdb.py

#####################################################################################
###
### Acme Software Works, Inc.
###
### Created June 16, 2019 by Don Dugger
###
### <PRE>
### Copyright 2019 Acme Software Works, Inc.
### 
### Redistribution and use in source and binary forms, with or without
### modification, are permitted provided that the following conditions are met:
### 
### 1. Redistributions of source code must retain the above copyright notice,
###    this list of conditions and the following disclaimer.
### 
### 2. Redistributions in binary form must reproduce the above copyright notice,
###    this list of conditions and the following disclaimer in the documentation
###    and/or other materials provided with the distribution.
### 
### THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
### AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
### IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
### ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
### LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
### CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
### GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
### HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
### LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
### OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
### <PRE>
#####################################################################################
import mysql.connector
from libprompt import config


# A simple to abstract access to the prompt database table. 
class PromptDB():
    # The constructor gets the configuration and connects to MySql.
    def __init__(self):
        self.config = config
        self.cnx = None
        self.setup()

    def setup(self):
        self.cnx = mysql.connector.connect(**self.config)
        
    # Makes sure the connect is closed.
    def __del__(self):
        if self.cnx != None:
            self.cnx.close()
    # Safe way to close.
    def close(self):
        if self.cnx != None:
            self.cnx.close()
        self.cnx = None

    # Get the full list of prompts.
    def fetchAllPrompts(self):
        cursor = self.cnx.cursor()
        cursor.execute("SELECT id,date,time,freq,text,count FROM tasks")
        return cursor.fetchall();

    # Get a prompt by the ID.
    def fetchOnePrompt(self,id):
        cursor = self.cnx.cursor()
        cursor.execute("SELECT id,date,time,freq,text,count FROM tasks WHERE id ={}".format(id))
        return cursor.fetchone();

    # Delete a prompt by ID.
    def delPrompt(self,id):
        cursor = self.cnx.cursor()
        cursor.execute("DELETE FROM tasks WHERE id={}".format(id))

    # Add a prompt to the table and return the ID.
    def addPrompt(self,date_str,time_str,freq_str,task_str,count):
        cursor = self.cnx.cursor()
        cursor.execute("INSERT INTO tasks (date,time,freq,text,count) VALUES ('{}','{}','{}','{}','{}')".format(date_str,time_str,freq_str,task_str,count))
        return int(cursor.lastrowid)
        
    # Update the prompt by ID.
    def editPrompt(self,id,date_str,time_str,freq_str,task_str):
        cursor = self.cnx.cursor()
        cursor.execute("UPDATE tasks SET date='{}',time='{}',freq='{}',text='{}' WHERE id={}".format(date_str,time_str,freq_str,task_str,id))
        
    # Update the prompt date by ID. 
    def setDate(self,id,date_str):
        cursor = self.cnx.cursor()
        cursor.execute("UPDATE tasks SET date='{}' WHERE id={}".format(date_str,id))

    # Update the count field by ID.
    def setCount(self,id,count):
        cursor = self.cnx.cursor()
        cursor.execute("UPDATE tasks SET count='{}' WHERE id={}".format(count,id))
        
                    

taskprompt.sql

/*
Copyright (c) 2019 Acme Software Works

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.
*/

DROP TABLE IF EXISTS `tasks`;
CREATE TABLE `tasks` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `date` date,
  `time` time,
  `freq` varchar(16) DEFAULT "",
  `text` varchar(64) DEFAULT "",
  `count` init(10) DEFAULT 0,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;