changes recording datatype from BLOB to VARCHAR, as I made up my mind and think, that storing the recordings as files somewhere is better than putting them in the database. recording should point to the path where the file can be found. (Maybe is copied and renamed to a nice place within the userspace)

README.md

@@ -18,8 +18,15 @@ At the moment, an alpha version is undertaken, with these features:
 - Set an active user (`a number_of_user`)
 - Show the pieces stored in the database (`s`)
 - Mark pieces as mastered for the active user (`m number_of_work`)
-- (planned) Show pieces by composer
+- Show pieces by composer (`c` shows composers, `s number_of_composer` shows pieces)
-- (planned) Show movements through pieces
+- Show movements through works (`sw work_number`)
+- Mark movement as mastered for active user (`m number_of_work number_of_movement`)
+- Show possible commands (`h`)
+- Show mastered movements for activated user (`sm`)
+- (planned) display, if work or movement is mastered from active user when viewing works and movements
+- (planned) Save recordings per movement in db
+- (planned) Listen to saved recordings
+- (planned) Works are shown sorted (opus, collection e.g. "Walzer", "Sonaten")
 
 ## Requirements
 

rep_cli.py

@@ -6,8 +6,20 @@ class Session:
         self.user = -1
         self.db_agent = db_agent
         self.resultstring = 'no results yet'
+        self.commands = {'a': (self.set_user, 'Set an active user\n   Usage: a number_of_user'),
+                         'c': (self.show_composers, 'Shows composers'),
+                         'h': (self.show_help, 'Displays this help document'),
+                         'm': (self.mark_work_as_mastered, 'Marks work or movement as mastered for the active user\n   Usage: m number_of_work, m number_of_work number_of_movement'),
+                         'n': (self.create_new_user, 'Creates new user\n   Usage: n firstname name'),
+                         's': (self.show_works, 'Show the works stored in the database\n   Usage: s, s number_of_composer'),
+                         'sm': (self.show_mastered, 'Show mastered movements for activated user'),
+                         'sw': (self.show_movements, 'Show movements of a work\n   Usage: sw work_number'),
+                         'su': (self.show_users, 'Show all users'),
+                         'q': (self.quit, 'Quits the program')
+                        }
 
-    def set_user(self, db_index):
+    def set_user(self, arguments):
+        db_index = arguments[0]
         self.user = db_index
         return 'User set'
 
@@ -27,33 +39,86 @@ class Session:
 
     def invoke_command(self, command, arguments):
         self.resultstring = ''
-        if command == 'a':
+        if command in self.commands.keys():
-            self.resultstring += self.set_user(arguments[0])
+            self.resultstring += self.commands[command][0](arguments)
-        elif command == 'm':
-            self.resultstring += self.mark_work_as_mastered(arguments[0])
-        elif command == 'n':
-            self.create_new_user(arguments[0], arguments[1])
-            self.resultstring += f'Created new user {arguments[0]} {arguments[1]}.'
-        elif command == 's':
-            self.resultstring += self.show_works()
-        elif command == 'su':
-            self.resultstring += self.show_users()
-        elif command == 'q':
-            self.resultstring += 'Bye-bye'
         else:
             self.resultstring += 'Could not understand command.'
 
     def result(self):
         return self.resultstring
     
-    def create_new_user(self, first_name, name):
+    def create_new_user(self, arguments):
+        first_name, name = arguments[0], arguments[1]
         sql_command = f'''
                       INSERT INTO pianist (first_name, sec_name)
                       VALUES ("{first_name}", "{name}");
                       '''
         self.db_agent.execute(sql_command)
+        return f'Created new user {first_name} {name}.'
 
-    def show_users(self):
+    def show_composers(self, _):
+        sql_command = '''
+                      SELECT id, first_name, name
+                      FROM composer
+                      ORDER BY name
+                      '''
+        result_list = self.db_agent.execute(sql_command).fetchall()
+        fun_resultstring = ''
+        for item in result_list:
+            fun_resultstring += f'{item[0]}: {item[2]}, {item[1]}\n'
+        return fun_resultstring
+
+    def show_help(self, arguments):
+        fun_resultstring = ''
+        if len(arguments) > 0:
+            qu_com = arguments[0]
+            if qu_com in self.commands:
+                fun_resultstring += f'{qu_com}: {self.commands[qu_com][1]}'
+            else:
+                fun_resultstring += f'Command {qu_com} not known, for help press h'
+        else:
+            for key, value in self.commands.items():
+                fun_resultstring += f'{key}: {value[1]}\n'
+        return fun_resultstring
+
+    def show_mastered(self, _):
+        fun_resultstring = 'Please activate user'
+        if not self.user == -1:
+            sql_command = f'''
+                          SELECT work_id
+                          FROM is_able_to_play
+                          WHERE pianist_id = {self.user}
+                          GROUP BY work_id
+                          '''
+            list_of_work_ids = self.db_agent.execute(sql_command).fetchall()
+            list_of_works = list()
+            for item in list_of_work_ids:
+                list_of_works.append(work_under_id(item[0], self.db_agent))
+            fun_resultstring = 'All mastered movements:\n'
+            for work in list_of_works:
+                for mov_number in work.values['movements'].keys():
+                    # check if movement is mastered
+                    sql_command = f'''
+                                  SELECT *
+                                  FROM is_able_to_play
+                                  WHERE work_id = {work.id()}
+                                    AND mov_id = {mov_number}
+                                    AND pianist_id = {self.user}
+                                  '''
+                    is_mastered = len(self.db_agent.execute(sql_command).fetchall()) > 0
+                    if is_mastered:
+                        fun_resultstring += f'{work.id()} {mov_number}. {work.pretty_mov(mov_number)}\n'
+        return fun_resultstring
+
+    def show_movements(self, arguments):
+        work_id = arguments[0]
+        work = work_under_id(work_id, self.db_agent)
+        fun_resultstring = ''
+        for mov_number in work.values['movements'].keys():
+            fun_resultstring += f'{mov_number}. {work.pretty_mov(mov_number)}\n'
+        return fun_resultstring
+
+    def show_users(self, _):
         sql_command = '''
                       SELECT * FROM pianist;
                       '''
@@ -63,10 +128,15 @@ class Session:
             fun_resultstring += f'{item[0]}: {item[1]} {item[2]}\n'
         return fun_resultstring
 
-    def show_works(self):
+    def show_works(self, arguments):
-        sql_command = '''
+        if len(arguments) > 0: 
+            restraint = f'comp_id = {arguments[0]}'
+        else:
+            restraint = '1 = 1'
+        sql_command = f'''
                       SELECT id
                       FROM work
+                      WHERE {restraint} 
                       '''
         list_of_work_ids = self.db_agent.execute(sql_command).fetchall()
         # GET WORKS OUT!
@@ -78,18 +148,31 @@ class Session:
             fun_resultstring += f'{work.id()}: {work.pretty_string()}\n'
         return fun_resultstring
 
-    def mark_work_as_mastered(self, work_id):
+    def mark_work_as_mastered(self, arguments):
+        work_id = arguments[0]
         resultstring = 'adding:\n'
         work = work_under_id(work_id, self.db_agent)
-        for mov_number in work.values['movements'].keys():
+        if len(arguments) > 1: # in case there is a movement number given
+            mov_number = int(arguments[1])
             sql_command = f'''
                           INSERT INTO is_able_to_play (work_id, mov_id, pianist_id)
                           VALUES ({work_id}, {mov_number}, {self.user})
                           '''
             self.db_agent.execute(sql_command)
             resultstring += f'{work.pretty_mov(mov_number)}\n'
+        else: # mark all movements of the work as mastered
+            for mov_number in work.values['movements'].keys():
+                sql_command = f'''
+                              INSERT INTO is_able_to_play (work_id, mov_id, pianist_id)
+                              VALUES ({work_id}, {mov_number}, {self.user})
+                              '''
+                self.db_agent.execute(sql_command)
+                resultstring += f'{work.pretty_mov(mov_number)}\n'
         return resultstring
 
+    def quit(self, _):
+        return 'Bye bye!'
+
 # End session
 
 class work_under_id:
@@ -127,7 +210,7 @@ class work_under_id:
         saetze = dict()
         nummern = set()
         suw_liste = self.reader.execute(sql_suw).fetchall()
-        # 0 work_id, 1 mov_number, 2 numb, 3 designation, 4 mus_key, 5 recording
+        # 0 work_id, 1 mov_number, 2 numb, 3 designation, 4 mus_key
         for satz in suw_liste:
             saetze[satz[1]] = satz[2], satz[3], satz[4]
             if not satz[2] is None:
@@ -200,10 +283,10 @@ class work_under_id:
 
 # End work_under_id
 
-def parse_user_input(user_in):
+def parse_user_input(user_in, session):
     split_user_in = user_in.split()
     command = split_user_in[0]
-    if command in ('a', 'm', 'n', 'q', 's', 'su'):
+    if command in session.commands.keys():
         arguments = split_user_in[1:]
         return (command, arguments)
     else:
@@ -213,9 +296,8 @@ def command_line_loop(session):
     user_in = ''
     while not user_in == 'q':
         user_in = input(f'Piano-Repertoire: {session.get_active_user()} >>> ')
-        command, arguments = parse_user_input(user_in)
+        command, arguments = parse_user_input(user_in, session)
         session.invoke_command(command, arguments)
-        # print(f'command: {command}, arguments: {arguments}')
         print(session.result())
 
 def main():

repertoire.sql

@@ -27,7 +27,6 @@ CREATE TABLE movement (
     numb VARCHAR(15),
     designation VARCHAR(63),
     mus_key VARCHAR(15),
-    recording BLOB,
     PRIMARY KEY(work_id, mov_number),
     FOREIGN KEY(work_id) REFERENCES work(id)
 );
@@ -50,6 +49,7 @@ CREATE TABLE is_able_to_play(
     mov_id INTEGER NOT NULL,
     pianist_id INTEGER NOT NULL,
     days_to_practice INTEGER DEFAULT 7,
+    recording VARCHAR(255),
     PRIMARY KEY(work_id, mov_id, pianist_id),
     FOREIGN KEY(work_id, mov_id) REFERENCES movement(work_id, mov_number),
     FOREIGN KEY(pianist_id) REFERENCES pianist(id)