optimized screen clear

.gitignore

@@ -0,0 +1,4 @@
+*.log
+*.conf
+*.db
+.vscode

README.md

@@ -1,25 +0,0 @@
-# Timetrack
-Simple time tracking
-
-## Requirements 
-- Python 3.7 or higher
-
-## Usage
-*as of v.2.1.0a*  
-Start the script and follow the menu.  
-Currently no further usability. 
-
-## Agenda
-- [ ] [Reports](https://git.4nima.net/anima/timetrack/issues/13)
-    - [x] by day  
-    - [ ] by week  
-    - [ ] by month  
-    - [ ] by user  
-- [ ] [Manual time entries](https://git.4nima.net/anima/timetrack/issues/6)
-- [ ] [Break in time entries](https://git.4nima.net/anima/timetrack/issues/5)
-    - [ ] [Short side tasks](https://git.4nima.net/anima/timetrack/issues/12)
-- [x] User management
-- [ ] [Categories](https://git.4nima.net/anima/timetrack/issues/7)
-- [ ] [Clients](https://git.4nima.net/anima/timetrack/issues/8)
-- [ ] [References](https://git.4nima.net/anima/timetrack/issues/9)
-- [ ] [GUI](https://git.4nima.net/anima/timetrack/issues/10)

timeTrack.py

@@ -3,7 +3,7 @@
 #
 # timeTrack.py
 # by 4nima
-# v.2.2.0a
+# v.2.0.4
 #
 #########################
 # simple time tracking with database 
@@ -23,73 +23,30 @@ class TimeTrack:
         self.USERID     = 0
         self.USERNAME   = ''
         self.OLDEVENT   = 2
-        self.CLIENTS    = False
-        self.CATEGORIES = False
-        self.REFERENCES = False
         self.LOGFILE    = 'timetrack.log'
+        self.DBCON     =  sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES)
         logging.basicConfig(
             filename=self.LOGFILE,
             level=logging.DEBUG, 
             format='%(asctime)s - %(process)d-%(levelname)s: %(message)s',
             datefmt='%Y-%m-%d %H:%M:%S'
         )
-        if os.name == 'posix':
-            logging.debug('Unix/Linux system detected')
-            self.LINUX = True
-        else:
-            logging.debug('Winwos System detected')
-            self.LINUX = False
-
         self.db_setup()
         self.load_config()
 
+    def __del__(self):
+        self.DBCON.close()
+    
     ## Prepartation
-    #==============
     ### Check OS and clear screen
     def clear_screen(self):
-        if self.LINUX:
+        if os.name == 'posix':
+            logging.debug('Unix/Linux system detected')
             _ = os.system('clear')
         else:
+            logging.debug('Winwos System detected')
             _ = os.system('cls')
             
-    ### Loads or creates a config file
-    def load_config(self):
-        if os.path.isfile(self.CONFIG):
-            logging.info('Config file was found')
-            try:
-                with open(self.CONFIG) as config_data:
-                    data = json.load(config_data)
-            except ValueError:
-                logging.error('Config file has no valid JSON syntax')
-                print('TimeTrack wird beendet: Fehler in der JSON-Konfig ({})'.format(self.CONFIG))
-                quit()
-            else:
-                logging.info('Config file was loaded successfully')
-                self.USERID     = data['userid']
-                self.OLDEVENT   = data['oldevent']
-                self.CLIENTS    = data['clients']
-                self.CATEGORIES = data['categories']
-                self.REFERENCES = data['references']
-                logging.debug('UserID {} was used'.format(data['userid']))
-                self.set_user()
-
-        else:
-            logging.warning('Config file not found')
-            config = {
-                'default' : 'interactive',
-                'userid' : 1,
-                'oldevent' : 2,
-                'clients' : False,
-                'categories' : False,
-                'references' : False
-            }
-            with open(self.CONFIG, "w") as outfile:
-                json.dump(config, outfile, indent=4, sort_keys=True)
-                logging.info('Config file created successfully')
-
-            #> wenn man keine datei erstellen darf/kann, fällt das skript in einen loop ?
-            self.load_config()
-            
     ### Creates a database if none is found
     def db_setup(self):
         if os.path.isfile(self.DATABASE):
@@ -103,11 +60,9 @@ class TimeTrack:
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 starttime TIMESTAMP NOT NULL,
                 endtime TIMESTAMP NOT NULL,
-                breaktime1 TIMESTAMP,
                 user_id INTEGER NOT NULL,
                 activity TEXT,
-                reference TEXT,
+                catrgory_id INTEGER,
-                category_id INTEGER,
                 client_id INTEGER,
                 lock BOOLEAN
             )
@@ -117,7 +72,6 @@ class TimeTrack:
             CREATE TABLE IF NOT EXISTS active_events (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 starttime TIMESTAMP NOT NULL,
-                breaktime TIMESTAMP,
                 user_id INT NOT NULL
             )
         """)
@@ -147,7 +101,7 @@ class TimeTrack:
 
         logging.debug('Create initial database tables')
         try:
-            with sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES) as con:
+            with self.DBCON as con:
                 for SQL in sql:
                     con.execute(SQL)
         except sqlite3.Error as err:
@@ -159,122 +113,39 @@ class TimeTrack:
         else:
             logging.debug('Table was created successfully or already exists')
 
-    ### Get an active event based on a user or event ID
+    ### Loads or creates a config file
-    def get_active_event(self, USERID='', EVENTID=''):
+    def load_config(self):
-        if USERID:
+        if os.path.isfile(self.CONFIG):
-            logging.debug('Search events based on userid: {}'.format(USERID))
+            logging.info('Config file was found')
-            sql = "SELECT * FROM active_events WHERE user_id = ?"
+            try:
-            searchdata = [USERID]
+                with open(self.CONFIG) as config_data:
-        elif EVENTID:
+                    data = json.load(config_data)
-            logging.debug('Search event based on eventid: {}'.format(EVENTID))
+            except ValueError:
-            sql = "SELECT * FROM active_events WHERE id = ?"
+                logging.error('Config file has no valid JSON syntax')
-            searchdata = [EVENTID]
+                print('TimeTrack wird beendet: Fehler in der JSON-Konfig ({})'.format(self.CONFIG))
-        else:
+                quit()
-            sql = "SELECT * FROM active_events"
+            else:
-            searchdata = False
+                logging.info('Config file was loaded successfully')
+                self.USERID = data['user']
+                self.OLDEVENT = data['oldevent']
+                logging.debug('UserID {} was used'.format(data['user']))
+                self.set_user()
 
-        try:
-            with sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES) as con:
-                cur = con.cursor()
-                if searchdata:
-                    logging.debug('Search event')
-                    cur.execute(sql, searchdata)
-                else:
-                    logging.debug('Get all Events')
-                    cur.execute(sql)
-                eventdata = cur.fetchall()
-        except sqlite3.Error as err:
-            logging.debug(sql)
-            logging.error('SQLError: {}'.format(err))
-            print('Fehler beim auslesen der aktiven Events')
         else:
-            logging.debug('Events could be read out successfully')
+            logging.warning('Config file not found')
+            config = {
+                'default' : 'interactive',
+                'user' : 1,
+                'oldevent' : 2
+            }
+            with open(self.CONFIG, "w") as outfile:
+                json.dump(config, outfile, indent=4, sort_keys=True)
+                logging.info('Config file created successfully')
 
-        con.close()
+            #> wenn man keine datei erstellen darf/kann, fällt das skript in einen loop ?
-        if eventdata == []:
+            self.load_config()
-            logging.debug('No active events found')
-            return 0
-        else:
-            logging.debug('{} events found'.format(len(eventdata)))
-            return eventdata[0]
-
-    ### Get time entries based on various criteria
-    def get_time_entry(self, USERID='', TIMEID='', CATEGORYID='', CLIENTID='', REFERENCE='', STARTTIME='', ENDTIME='', DAY=''):
-        if USERID:
-            logging.debug('Search time entries based on userid: {}'.format(USERID))
-            sql = "SELECT * FROM time_entries WHERE user_id = ?"
-            searchdata = [USERID]
-        elif TIMEID:
-            logging.debug('Search time entrys based on timeid: {}'.format(TIMEID))
-            sql = "SELECT * FROM time_entries WHERE id = ?"
-            searchdata = [TIMEID]
-        elif CATEGORYID:
-            logging.debug('Search time entrys based on categoryid: {}'.format(CATEGORYID))
-            sql = "SELECT * FROM time_entries WHERE category_id = ?"
-            searchdata = [CATEGORYID]
-        elif CLIENTID:
-            logging.debug('Search time entrys based on clientid: {}'.format(CLIENTID))
-            sql = "SELECT * FROM time_entries WHERE client_id = ?"
-            searchdata = [CLIENTID]
-        elif REFERENCE:
-            logging.debug('Search time entrys based on reference: {}'.format(REFERENCE))
-            sql = "SELECT * FROM time_entries WHERE reference = ?"
-            searchdata = [REFERENCE]
-        else:
-            sql = "SELECT * FROM time_entries"
-            searchdata = False
-            
-        try:
-            with sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES) as con:
-                cur = con.cursor()
-                if searchdata:
-                    logging.debug('Search time entry')
-                    cur.execute(sql, searchdata)
-                else:
-                    logging.debug('Get all time entries')
-                    cur.execute(sql)
-                timedata = cur.fetchall()
-        except sqlite3.Error as err:
-            logging.debug(sql)
-            logging.error('SQLError: {}'.format(err))
-            print('Fehler beim auslesen der Zeiteinträge')
-        else:
-            logging.debug('Time entries could be read out successfully')
-
-        con.close()
-
-        if DAY:
-            logging.debug('Search time entries by date: {}'.format(DAY))
-            tmp = []
-            for entry in timedata:
-                if entry[1].date() == DAY:
-                    tmp.append(entry)
-            timedata = tmp[:]
-        else:
-            tmp = []
-            if STARTTIME:
-                logging.debug('Search time entries by starttime: {}'.format(STARTTIME))
-                for entry in timedata:
-                    if entry[1] > STARTTIME:
-                        tmp.append(entry)
-                timedata = tmp[:]
-                pass
-            tmp = []
-            if ENDTIME:
-                logging.debug('Search time entrie by endtime: {}'.format(ENDTIME))
-                for entry in timedata:
-                    if entry[2] < ENDTIME:
-                        tmp.append(entry)
-                timedata = tmp[:]
-        if timedata == []:
-            logging.debug('No time entries found')
-            return 0
-        else:
-            logging.debug('{} time entries found'.format(len(timedata)))
-            return timedata
 
     ## user handling
-    #===============
     ### Creates a user who does not yet exist
     def create_user(self, USER=''):
         if USER == '':
@@ -291,9 +162,8 @@ class TimeTrack:
         logging.debug('Accepted username: {}'.format(username))
 
         sql = "INSERT INTO users ( name ) values ( ? )"
-
         try:
-            with sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES) as con:
+            with self.DBCON as con:
                 con.execute(sql, [username])
         except sqlite3.Error as err:
             logging.error('User could not be saved in database')
@@ -318,7 +188,7 @@ class TimeTrack:
             sql = "SELECT * FROM users"
         
         try:
-            with sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES) as con:
+            with self.DBCON as con:
                 cur = con.cursor()
                 if data:
                     cur.execute(sql, [data])
@@ -350,33 +220,15 @@ class TimeTrack:
         else: 
             self.USERNAME = data[0][1]
 
-    def delete_user(self, UID=False):
-        if not UID:
-            logging.error('no userid passed for deletion')
-        else:
-            logging.debug('Userid {} will be delete'.format(UID))
-            sql = "DELETE FROM users WHERE id = ?"
-
-            try:
-                with sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES) as con:
-                    con.execute(sql, [UID])
-            except sqlite3.Error as err:
-                logging.error('User could not be delete from database')
-                logging.debug(sql)
-                logging.error('SQLError: {}'.format(err))
-            else:
-                logging.info('User was delete successfully')
-
     ## Time handling
-    #===============
     ### Creates an active event if none exists for the user
     def save_event(self, TIME=datetime.datetime.now()):
-        if not self.get_active_event(USERID=self.USERID):
+        if not self.get_event(USERID=self.USERID):
             logging.debug('No active events found for the user: {}'.format(self.USERID))
 
             sql = "INSERT INTO active_events ( starttime, user_id ) VALUES ( ?, ? )"
             try:
-                with sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES) as con:
+                with self.DBCON as con:
                     con.execute(sql, [TIME, self.USERID])
             except sqlite3.Error as err:
                 logging.error('Event could not be created')
@@ -409,7 +261,7 @@ class TimeTrack:
             return 0
 
         try:
-            with sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES) as con:
+            with self.DBCON as con:
                 con.execute(sql, [data])
         except sqlite3.Error as err:
             logging.error('Event could not be deleted')
@@ -419,7 +271,45 @@ class TimeTrack:
         else:
             logging.debug('Event was successfully deleted')
 
-    ### Checks for existing time entries and creates a new one if none is available.
+    ### Get an active event based on a user or event ID
+    def get_event(self, ENTRYID='', USERID=''):
+        if not ENTRYID == '':
+            logging.debug('Search event based on eventid: {}'.format(ENTRYID))
+            sql = "SELECT * FROM active_events WHERE id = ?"
+            data = ENTRYID
+        elif not USERID == '':
+            logging.debug('Search events based on userid: {}'.format(USERID))
+            sql = "SELECT * FROM active_events WHERE user_id = ?"
+            data = USERID
+        else:
+            sql = "SELECT * FROM active_events"
+            data = ''
+            
+        try:
+            with self.DBCON as con:
+                cur = con.cursor()
+                if data:
+                    logging.debug('Search event')
+                    cur.execute(sql, [data])
+                else:
+                    logging.debug('Get all Events')
+                    cur.execute(sql)
+                data = cur.fetchall()
+        except sqlite3.Error as err:
+            logging.error('Events could not be read')
+            logging.debug(sql)
+            logging.error('SQLError: {}'.format(err))
+            print('Fehler beim auslesen der aktiven Events')
+        else:
+            logging.debug('Events could be read out successfully')
+        
+        if data == []:
+            logging.debug('No active events found')
+            return 0
+        else:
+            logging.debug('{} events found'.format(len(data)))
+            return data[0]
+
     def time_start(self, AUTOFORWARD=True):
         self.clear_screen()
         starttime = datetime.datetime.now()
@@ -429,7 +319,7 @@ class TimeTrack:
             if AUTOFORWARD:
                 self.time_stop()
         else:
-            data = self.get_active_event(USERID=self.USERID)
+            data = self.get_event(USERID=self.USERID)
             print('Es existiert bereits ein aktives Event.')
             if (data[1] + datetime.timedelta(hours=self.OLDEVENT)) <= datetime.datetime.now():
                 logging.info('Event exceeds allowed duration')
@@ -448,44 +338,56 @@ class TimeTrack:
                     logging.debug('Event younger than 1 day')
                     print('Vergangene Zeit: >{} Stunden'.format(int(elapsed.seconds/3600)))
 
-                printtext = [
+                userinput = 0
-                    'Wie soll mit dem Event verfahren werden?',
+                while not 0 < int(userinput) < 4:
-                    '[1] fortsetzen',
+                    print('Soll das Event fortgesetzt oder gelöscht werden?')
-                    '[2] löschen',
+                    print('[1] für fortsetzen')
-                    '[0] abbrechen'
+                    print('[2] für löschen')
-                ]
+                    print('[3] für abbrechen')
-                userinput = self.userchoise(printtext, 3)
+                    userinput = input('Aktion: ')
-                self.clear_screen()
+                    logging.debug('User input: {}'.format(userinput))
+                    try:
+                        int(userinput)
+                    except ValueError:
+                        userinput = 0
+                    self.clear_screen()
 
-                if userinput == 1:
+                if userinput == "1":
                     logging.debug('Event should be continued')
                     self.time_stop()
-                elif userinput == 2:
+                elif userinput == "2":
                     logging.info('Event should be deleted (eventid: {})'.format(data[0]))
                     self.delete_event(data[0])
                     self.time_start()
+                else:
+                    logging.debug('Terminated by the user')
+                    exit()
             
             else:
                 logging.debug('Event continues (eventid{})'.format(data[0]))
                 print('Event von {} Uhr geladen'.format(data[1].strftime("%H:%M")))
                 self.time_stop()
 
-    ### Stops existing time entries
     def time_stop(self):
-        data = self.get_active_event(USERID=self.USERID)
+        data = self.get_event(USERID=self.USERID)
         logging.debug('Event stop progess is started')
         if data:
             self.clear_screen()
-            printtext = [
+            userinput = 0
-                'Event von {} Uhr beenden?'.format(data[1].strftime("%H:%M")),
+            while not 0 < int(userinput) < 4:
-                '[1] für beenden',
+                print('Event von {} Uhr beenden?'.format(data[1].strftime("%H:%M")))
-                '[2] für löschen',
+                print('[1] für beenden')
-                '[0] für abbrechen'
+                print('[2] für löschen')
-            ]
+                print('[3] für abbrechen')
-            userinput = self.userchoise(printtext, 3)
+                userinput = input('Aktion: ')
-            self.clear_screen()
+                logging.debug('User input: {}'.format(userinput))
+                try:
+                    int(userinput)
+                except ValueError:
+                    userinput = 0
+                self.clear_screen()
 
-            if userinput == 1:
+            if userinput == "1":
                 logging.debug('Event is ended')
                 print('Eingabe beenden mittels doppelter Leerzeile.')
                 print('Durchgeführte Tätigkeiten:')
@@ -512,7 +414,7 @@ class TimeTrack:
 
                 sql = "INSERT INTO time_entries ( starttime, endtime, user_id, activity ) VALUES ( ?, ?, ?, ? )"
                 try:
-                    with sqlite3.connect(self.DATABASE, detect_types=sqlite3.PARSE_DECLTYPES | sqlite3.PARSE_COLNAMES) as con:
+                    with self.DBCON as con:
                         con.execute(sql, [data[1], endtime, self.USERID, action])
                 except sqlite3.Error as err:
                     logging.error('Time entry could not be created')
@@ -524,175 +426,39 @@ class TimeTrack:
                     logging.info('Time entry was created successfully')
                 
                 self.delete_event(data[0])
-                self.clear_screen()
                 self.print_time_entry(STARTTIME=data[1], ENDTIME=endtime, ACTIVITY=action)
                 print('Zeiteintrag wurde gespeichert.')
-                printtext = [
+                userinput = 0
-                    'Nächsten Zeiteintrag beginnen ?',
+                while not 0 < int(userinput) < 3:
-                    '[1] Ja',
+                    print('Nächsten Zeiteintrag beginnen ?')
-                    '[0] Nein'
+                    print('[1] Ja')
-                ]
+                    print('[2] Nein')
-                userinput = self.userchoise(printtext)
+                    userinput = input('Aktion: ')
-                self.clear_screen()
+                    logging.debug('User input: {}'.format(userinput))
+                    try:
+                        int(userinput)
+                    except ValueError:
+                        userinput = 0
+                    self.clear_screen()
 
-                if userinput == 1:
+                if userinput == "1":
                     self.time_start()
+                else:
+                    logging.debug('Terminated by the user')
+                    exit()
 
-            elif userinput == 2:
+            elif userinput == "2":
                 logging.info('Event should be deleted (eventid: {})'.format(data[0]))
                 self.delete_event(data[0])
+            else:
+                logging.debug('Terminated by the user')
+                exit()
 
-    ## Interactive mode
+    def get_time(self):
-    #==================
+        pass
-    ### Main menu of the interactive menu
-    def start_interactive_mode(self):
-        self.clear_screen()
-        printtext = [
-            '=> Hauptmenü - Angemeldet als {}'.format(self.USERNAME),
-            'Was willst du tun?',
-            '[1] Zeiterfassung starten',
-            '[2] heutiger Report',
-            '[3] Reports',
-            '[4] Benutzerverwaltung',
-            '[0] Programm verlassen'
-        ]
-        userinput = self.userchoise(printtext, 4)
 
-        if userinput == 1:
-            logging.debug('Start TimeTrack')
-            self.time_start()
-        elif userinput == 2:
-            logging.info('Print todays report')
-            self.report_by_day(DETAIL=True)
-            input()
-        elif userinput == 3:
-            self.interactive_reports()
-        elif userinput == 4:
-            self.interactive_usermanagment()
-        else:
-            exit()
-        self.start_interactive_mode()
-    
-    ### Reports menu
-    def interactive_reports(self):
-        self.clear_screen()
-        printtext = [
-            '==> Reports für {}'.format(self.USERNAME),
-            'Welcher Report soll angezeigt werden?',
-            '[1] Tages Report von [Datum]',
-            '[0] abbrechen'
-        ]
-        userinput = self.userchoise(printtext, 2)
-
-        if userinput == 1:
-            valid = False
-            while not valid:
-                self.clear_screen()
-                print('Report für welches Datum soll angezeigt werden?')
-                print('[0] für abbruch')
-                userdate = input("Datum: [yyyy-mm-dd]:")
-                if userdate == 0:
-                    break
-                else:
-                    try:
-                        date = datetime.datetime.strptime(userdate, "%Y-%m-%d")
-                        valid = True
-                    except:
-                        pass
-            self.report_by_day(date.date())
-
-    ### Usermanagment menu 
-    def interactive_usermanagment(self):
-        self.clear_screen()
-        printtext = [
-            '==> Benutzerverwaltung - Angemeldet als {}'.format(self.USERNAME),
-            'Was willst du tun?',
-            '[1] Benutzer anlegen',
-            '[2] Benutzer wechseln',
-            '[3] Benutzer löschen',
-            '[0] abbrechen'
-        ]
-        userinput = self.userchoise(printtext, 4)
-
-        if userinput == 1:
-            self.create_user()
-        elif userinput == 2:
-            users = self.get_users()
-            printtext = ['Wähle deinen User:']
-            count = 1
-            for user in users:
-                printtext.append('[{}] {}'.format(count, user[1]))
-                count += 1
-            
-            printtext.append('[0] abbrechen')
-            userid = self.userchoise(printtext, count)
-            self.USERID = users[userid - 1][0]
-            self.set_user()
-        elif userinput == 3:
-            users = self.get_users()
-            printtext = ['Welcher User soll gelöscht werden?:']
-            count = 1
-            for user in users:
-                printtext.append('[{}] {}'.format(count, user[1]))
-                count += 1
-            
-            printtext.append('[0] abbrechen')
-            userid = self.userchoise(printtext, count)
-            self.delete_user(users[userid - 1][0])
-
-    ## Reports
-    #=========
-    ### One day report, optionally with time entries
-    def report_by_day(self, DATE=datetime.date.today(), USER='', DETAIL=''):
-        if not USER: 
-            USER = self.USERID
-        timedata = self.get_time_entry(DAY=DATE, USERID=USER)
-        if timedata == 0:
-            print("Es wurden keine Zeiteinträge für den angegeben Tag gefunden")
-            logging.debug('No time entries for date: '.format(DATE))
-            input()
-            return 1
-        
-        STARTTIMES  = []
-        ENDTIMES    = []
-        DURATIONS   = []
-
-        for entry in timedata:
-            STARTTIMES.append(entry[1])
-            ENDTIMES.append(entry[2])
-            DURATIONS.append(entry[2] - entry[1])
-
-        if timedata:
-            FIRSTSTARTTIME  = min(STARTTIMES)
-            LASTENDTIME     = max(ENDTIMES)
-            TRACKEDTIMESPAN = (LASTENDTIME - FIRSTSTARTTIME)
-            TRACKEDTIME     = sum(DURATIONS, datetime.timedelta())
-            NONTRACKEDTIME  = (TRACKEDTIMESPAN - TRACKEDTIME)
-            ENTRIECOUNT     = len(timedata)
-            
-            self.clear_screen()
-            text = "{:40} {}"
-            print(text.format("Beginn des ersten Zeiteintrags:", FIRSTSTARTTIME.strftime('%d.%m.%Y %H:%M')))
-            print(text.format("Ende des letzen Zeiteintrags:", LASTENDTIME.strftime('%d.%m.%Y %H:%M')))
-            print(text.format("Maximal erfassbare Zeit:", self.timedela_to_string(TRACKEDTIMESPAN)))
-            print(text.format("Nicht erfasste Zeit:", self.timedela_to_string(NONTRACKEDTIME)))
-            print(text.format("Erfasste Zeit:", self.timedela_to_string(TRACKEDTIME)))
-            print(text.format("Zeiteinträge:", ENTRIECOUNT))
-
-            printtext = [
-                'Zeiteinträge anzeigen?',
-                '[1] Ja',
-                '[0] Nein'
-            ]
-            userinput = self.userchoise(printtext)
-            if userinput == 1:
-                for entry in timedata:
-                    self.print_time_entry(entry[1], entry[2], entry[4])
-
-    ## Outputs
-    #=========
-    ### Shows a time entry
     def print_time_entry(self, STARTTIME='', ENDTIME='', ACTIVITY=''):
+        self.clear_screen()
         s = (ENDTIME - STARTTIME).seconds
         hours, remainder = divmod(s, 3600)
         minutes, seconds = divmod(remainder, 60)
@@ -706,33 +472,7 @@ class TimeTrack:
             print(ACTIVITY)
         print(50*"-")
 
-    ## Miscellaneous
-    #===============
-    ### User selection
-    def userchoise(self, TEXT='', MAX=2):
-        userinput = -1
-        while not -1 < int(userinput) < MAX:
-            for text in TEXT:
-                print(text)
-            userinput = input('Aktion: ')
-            logging.debug('User input: {}'.format(userinput))
-            try:
-                int(userinput)
-            except ValueError:
-                userinput = -1
-            else:
-                self.clear_screen()
-        return int(userinput)
-
-    ### Conversion to string of Timedelta typ
-    def timedela_to_string(self, TIME):
-        s = TIME.seconds
-        hours, remainder = divmod(s, 3600)
-        minutes, seconds = divmod(remainder, 60)
-        output = '{:02}:{:02}:{:02}'.format(int(hours), int(minutes), int(seconds))
-        return output
-  
-
 if __name__ == "__main__":
     test = TimeTrack()
-    test.start_interactive_mode()
+    test.time_start()
+    test.DBCON.close()

timeTrack.sh

@@ -0,0 +1,540 @@
+#!/bin/bash
+#==========
+#
+# timeTrack.sh
+# by 4nima
+# v.1.5.0
+# 
+#==========
+# Einfaches Erfassen von Zeiten mit einer SQLDB (SQLite, kein Server) 
+#==========
+
+
+# Variablen Definieren
+#=====================
+# Pfad zur Datenbank (Vollständiger Pfad benutzen!) 
+DBDIR="/root/time/work/.timeTrack.db"
+DB="timeTrack"
+
+## Verfügbare Kategorien (0 = Default) 
+### ACHTUNG: in der DB werden die IDs gespeichert, verändern der Rheinfolge verfälscht Reports
+# Alternativ neben Kategorien noch Tags oder Projekte anbieten
+declare -a categories
+categories[0]="Junk"
+categories+=("Kunden")
+categories+=("Internes")
+categories+=("Meetings")
+categories+=("Schulung")
+categories+=("Pause")
+categories+=("Sonstiges")
+categories+=("Privates")
+
+# Funktionen
+#===========
+## DB
+### Erstellt eine Datenbank Datei
+function createDB {
+  sqlite3 $DBDIR "
+    CREATE TABLE IF NOT EXISTS $DB (
+      id INTEGER PRIMARY KEY,
+      date INTEGER,
+      day INTEGER,
+      kw INTEGER,
+      task TEXT,
+      category INTEGER,
+      worktime INTEGER
+    );
+  "
+}
+
+### Fügt einen Task in die DB ein
+function insertTask {
+  sqlite3 $DBDIR "
+    INSERT INTO $DB (
+      date,
+      day,
+      kw,
+      task,
+      category,
+      worktime
+    ) VALUES (
+      '$(date +%s)',
+      '$(date +%u)',
+      '$(date +%V)',
+      '$1',
+      '$2',
+      '$3'
+    );
+  "
+}
+
+### Eintrag aus der Datenbank löschen
+function eraseTask {
+  echo "<================================================>"
+  sqlite3 $DBDIR "
+    DELETE
+    FROM $DB
+    WHERE id = $DBID
+  "
+  echo "Task wurde gelöscht"
+  echo "<================================================>"
+}
+
+### Suche
+#### Anhand der ID
+function searchById {
+  echo "<================================================>"
+  sqlite3 $DBDIR -column -header "
+    SELECT *
+    FROM $DB
+    WHERE id = $DBID
+  "
+  echo "<================================================>"
+}
+
+#### Anhand eines Strings (in Tasks)
+function searchByString {
+  echo "<================================================>"
+  sqlite3 $DBDIR -column -header "
+    SELECT *
+    FROM $DB
+    WHERE task LIKE '%$SEARCH%' 
+  "
+  echo "<================================================>"
+}
+
+### Updates
+#### Datum
+function updateDate {
+  echo "<================================================>"
+  sqlite3 $DBDIR "
+    UPDATE $DB
+    SET date = '$UPDATEVALUE'
+    WHERE id = $DBID
+  "
+  echo "Datum geupdatet"
+  echo "<================================================>"
+}
+
+function updateTask {
+  echo "<================================================>"
+  sqlite3 $DBDIR "
+    UPDATE $DB
+    SET task = '$UPDATEVALUE'
+    WHERE id = $DBID
+  "
+  echo "Task geupdatet"
+  echo "<================================================>"
+}
+
+function updateCategory {
+  echo "<================================================>"
+  sqlite3 $DBDIR "
+    UPDATE $DB
+    SET category = '$UPDATEVALUE'
+    WHERE id = $DBID
+  "
+  echo "Kategorie geupdatet"
+  echo "<================================================>"
+}
+
+function updateWorktime {
+  echo "<================================================>"
+  sqlite3 $DBDIR "
+    UPDATE $DB
+    SET worktime = '$UPDATEVALUE'
+    WHERE id = $DBID
+  "
+  echo " Arbeitszeit geupdatet"
+  echo "<================================================>"
+}
+
+### Reports
+#### Auslesen aller Heutigen Tasks
+function dailyReport {
+  echo "<================================================>"
+  day=$(convertDay $(date +%u))
+  echo "Daly Report vom $day - KW $(date +%V)"
+  sqlite3 $DBDIR -column -header "
+    SELECT
+      count(id) AS 'Tasks',
+      time(sum(worktime), 'unixepoch') AS 'Arbeitszeit'
+    FROM $DB 
+    WHERE kw = '$(date +%V)'
+    AND day = '$(date +%u)' 
+  "
+  echo 
+}
+
+function weeklyReport {
+  echo "<================================================>"
+  echo "Weekly Report vom KW $(date +%V)"
+  sqlite3 $DBDIR -column -header "
+    SELECT 
+      count(id) AS 'Tasks',
+      time(sum(worktime), 'unixepoch') AS 'Arbeitszeit'
+    FROM $DB 
+    WHERE kw = '$(date +%V)'
+  "
+  echo
+}
+
+function dailyCategoryReport {
+  day=$(convertDay $(date +%u))
+  for i in ${!categories[@]}; do
+    echo "<================================================>"
+    echo "Report für Kategorie: ${categories[i]}"
+    echo "Für $day in KW: $(date +%V)"
+    sqlite3 $DBDIR -column -header "
+      SELECT  
+        count(id) AS 'Tasks',
+        time(sum(worktime), 'unixepoch') AS 'Arbeitszeit'
+      FROM $DB 
+      WHERE kw = '$(date +%V)'
+      AND day = '$(date +%u)'
+      AND category = '$i'
+    "
+    echo
+  done
+}
+
+function weeklyCategoryReport {
+  week=$(convertDay $(date +%u))
+  for i in ${!categories[@]}; do
+    echo "<================================================>"
+    echo "Report für Kategorie: ${categories[i]}"
+    echo "In KW: $(date +%V)"
+    sqlite3 $DBDIR -column -header "
+      SELECT  
+        count(id) AS 'Tasks',
+        time(sum(worktime), 'unixepoch') AS 'Arbeitszeit'
+      FROM $DB 
+      WHERE kw = '$(date +%V)'
+      AND category = '$i'
+    "
+    echo
+  done
+}
+
+## Abläufe
+### Prüft ob SQLite3 installiert ist und erstellt eine Datenbank wenn nicht schon vorhanden
+function checkRequirements {
+  dpkg -l sqlite3
+  if [ $? -ne 0 ]; then
+    echo "Bitte sqlite3 installieren!"
+    exit
+  fi
+  
+  if [ ! -d $DIR ];then
+    mkdir -r $DIR
+  fi
+  createDB
+}  
+ 
+### Start des Trackings und Tätigkeits Abfrage
+function startTracking {
+  starttime=$(date +%s)
+  echo "<================================================>"
+  echo "Time Tracking gestartet um: $(date +%H:%M)"
+  IFS= read -a doingwords -p "Tätigkeit? `echo $'\n> '`" 
+  doing=${doingwords[0]}
+}
+
+### Beendet das Tacking und Kategorie Abfrage
+function endTracking {
+  for i in ${!categories[@]}; do
+    echo "$i. ${categories[i]}"
+  done
+  IFS= read -p "Kategorie? `echo $'\n> '`" category
+  endtime=$(date +%s)
+  worktime=$(($endtime - $starttime))
+}
+
+### Erstellt eine Zusammenfassung zu dem eben Bearbeiteten Task
+#### Verbesserung: Möglichkeit auch Tasks aus der DB erneut auszugeben
+function printTask {
+  echo "<================================================>"
+  echo "Time Tracking beendet um $(date +%H:%M) - $outputtime"
+  echo "<================================================>"
+  echo "Du hast $outputtime in ${categories[$category]} investiert"
+  echo "<================================================>"
+  echo "Task: $doing"
+  echo "<================================================>"
+}
+
+### Aufruf bei -D(atenbank)
+function showDB {
+  sqlite3 $DBDIR -column -header  "SELECT * from $DB"
+}
+
+### Aufruf bei -c(onfig) [/path/to/config.file]
+function config {
+  if [ -f $OPTARG ];then 
+    config=$OPTARG
+    echo $config
+    # Datei einlesen; Prüfung was angepasst wurde (DB / DB file / Kategorien); validieren; weiter oder exit.
+  else 
+    echo "Dieses Konfigfile existiert nicht"
+    exit
+  fi
+}
+
+### Aufruf bei -e(rase) [DB ID]
+function erase {
+  if [[ $OPTARG =~ ^[0-9]+$ ]]; then
+    DBID=$OPTARG
+    searchById
+    IFS= read -p "Diesen Eintrag löschen?(y/n) `echo $'\n> '`" DELIT
+    if [ $DELIT == "Y" ] || [ $DELIT == "y" ]; then
+      eraseTask
+    fi
+  else
+    echo "Gib die ID des zu löschenden Tasks ein"
+    echo "Mit '-s' kannst du eine Suche starten"
+    exit
+  fi
+}
+
+### Aufruf bei -h(elp)
+function printHelp {
+  echo '
+    Benutzung: ./timeTrack.sh [option [argument]]
+
+    Ohne Option wird das Skript für eine Zeitmessung ausgeführt und dann beendet. 
+
+    Optionen: 
+      -D              # Listet die Tabelle der Datenbank auf
+      -c [arg]        # Konfigurationsdatei
+      -e [DB ID]      # Eintrag aus Tabelle löschen (Siehe -s)
+      -h              # Zeigt diese Hilfe
+      -H [option]     # Zeigt Detail Hilfe zu der Option
+      -i              # Startet eine Aufgaben speicherung mit eigenen Zeiteingaben
+      -l              # Startet das Skript im Loop (abbrechen mit Strg + C)
+      -r [type]       # Zeigt Reports für [day / week / month / category / ...]
+      -s [string]     # Sucht in der Datenbank nach [string] (nur im Aufgaben Feld)
+      -u [DB ID]      # Update für bereits vorhandene Einträge in der Datenbank (Siehe -s)
+  '
+}
+
+### Aufrug bei -H(elp) [option]
+function helpTo {
+  case $1 in
+    c)
+      echo '
+        Benutzung: ./timeTrack.sh -c /path/to/my.conf
+
+        Mit der Option -c kann ein eine Konigurationsdatei angegeben werden. 
+        In der Konfigurationsdatei können individuelle Parameter übergeben werden: 
+          Pfad zur Datenbankdatei:
+            DBDIR="/path/to/file.db"      # Vollständigen Pfad angeben
+
+          In der Datenbankdatei die Tabelle festlegen: 
+            DB="myTable"                  # Keine Sonder- oder Leerzeichen 
+        
+          Eigene Kategorien: 
+            categories[0]="Default")      # Standard Kategorie
+            categories+=("newCategory")   # Hinzufügen einer Kategorie (wiederholbar)
+      '
+      ;;
+    *)
+      exit
+      ;;
+  esac
+}      
+
+### Aufruf bei -i(nsert)
+function insert {
+  IFS= read -p "Tätigkeit? `echo $'\n> '`" TASK
+  IFS= read -p "Dauer? `echo $'\n> '`" WORKTIME 
+  IFS= read -p "Endzeit? `echo $'\n> '`" ENDDATE
+  IFS= read -p "Kategorie? `echo $'\n> '`" CATEGORY
+}
+
+### Aufruf bei -r(eport) [Ansicht...]
+function report {
+  REPORT=$OPTARG
+  clear
+  case $REPORT in
+    day|daily)
+      dailyReport
+      dailyCategoryReport
+      ;;
+    week|weekly)
+      weeklyReport
+      weeklyCategoryReport
+      ;;
+    *)
+      dailyReport
+      ;;
+  esac
+}
+
+### Standard Aufruf
+function default {
+  checkRequirements
+  clear
+  startTracking
+  endTracking
+  calcWorktime $worktime
+  insertTask "$doing" "$category" "$worktime"
+  clear
+  printTask
+}
+
+### Aufruf bei -s(earch) [Suchstring]
+function search {
+  # Optionen ob damit was gemacht werden soll (Update / Löschen)
+  SEARCH=$OPTARG
+  searchByString 
+}
+
+### Aufruf bei -u(pdate) [DB ID]
+function update {
+  # Prüfung ob angaben stimmen, weitere eingaben ändern
+  DBID=$OPTARG
+  searchById
+  echo "
+    1. Datum
+    2. Task
+    3. Kategorie
+    4. Arbeitszeit
+  "
+  IFS= read -p "Was soll geupdatet werden? `echo $'\n> '`" UPDATETYPE
+  IFS= read -p "Was soll eingetragen werden? `echo $'\n> '`" UPDATEVALUE
+  case $UPDATETYPE in
+    1|Datum)
+      updateDate
+      ;;
+    2|Task)
+      updateTask
+      ;;
+    3|Kategorie)
+      updateCategory
+      ;;
+    4|Arbeitszeit)
+      updateWorktime
+      ;;
+    *)
+      echo "Falsche angabe"
+      exit
+      ;;
+    esac
+}
+
+## Umwandlung / Umrechnung
+### Rechnet die Sekunden in Stunden und Minuten um
+function calcWorktime {
+  if [ $1 -ge 3600 ]; then
+    hworktime=$((worktime / 3600))
+    mworktime=$(((worktime % 3600) / 60))
+    gmworktime=$((worktime / 60))
+    outputtime="$gmworktime min ($hworktime:$mworktime H)"
+  else 
+    gmworktime=$((worktime / 60))
+    outputtime="$gmworktime min"
+  fi
+}
+
+function convertDay {
+  case $1 in
+    1)
+      echo "Montag"
+      ;;
+    2)
+      echo "Dienstag"
+      ;;
+    3)
+      echo "Mittwoch"
+      ;;
+    4)
+      echo "Donnerstag"
+      ;;
+    5)
+      echo "Freitag"
+      ;;
+    6)
+      echo "Samstag"
+      ;;
+    7)
+      echo "Sonntag"
+      ;;
+  esac
+}
+
+# Argumente auslesen
+#===============================
+while getopts "Dc:e:hH:ilr:s:Tu:" opt; do
+  case $opt in
+    D)
+      showDB
+      exit
+      ;;
+    c)
+      config
+      exit
+      ;;
+    e)
+      erase
+      exit
+      ;;
+    h)
+      printHelp
+      exit
+      ;;
+    H)
+      helpTo $OPTARG
+      exit
+      ;;
+    i)
+      insert
+      exit
+      ;;
+    l)
+      while true; do
+        default
+      done
+      ;;
+    r)
+      report
+      exit
+      ;;
+    s)
+      search
+      exit
+      ;;
+    T)
+      # Testing
+      results=($(sqlite3 $DBDIR "
+        SELECT *
+        FROM $DB
+      "))
+      
+      #for i in ${!results[@]}; do
+      for i in "${!results[@]}"; do
+        echo "<================================================>"
+        echo "Test für: ${results[i]}"
+
+        echo "Record No. $i: ${results[$i]}"
+
+
+        fieldA=${results[0]};
+        fieldB=${results[1]};
+        fieldC=${results[2]};
+        fieldD=${results[3]};
+
+      done
+
+      echo $fieldA $fieldB $fieldC $fieldD
+      exit
+      ;;
+    u)
+      update  
+      exit
+      ;;
+    *)
+      exit
+      ;;
+  esac
+done
+
+default