Add correction unlink command

NodeApp/src/commander/assignment/subcommands/correction/AssignmentCorrectionCommand.ts

 import CommanderCommand                  from '../../../CommanderCommand.js';
 import AssignmentCorrectionLinkCommand   from './subcommands/AssignmentCorrectionLinkCommand.js';
 import AssignmentCorrectionUpdateCommand from './subcommands/AssignmentCorrectionUpdateCommand.js';
+import AssignmentCorrectionUnlinkCommand from './subcommands/AssignmentCorrectionUnlinkCommand.js';
 
 
 class AssignmentCorrectionCommand extends CommanderCommand {
@@ -14,6 +15,7 @@ class AssignmentCorrectionCommand extends CommanderCommand {
     protected defineSubCommands() {
         AssignmentCorrectionLinkCommand.registerOnCommand(this.command);
         AssignmentCorrectionUpdateCommand.registerOnCommand(this.command);
+        AssignmentCorrectionUnlinkCommand.registerOnCommand(this.command);
     }
 
     protected async commandAction(): Promise<void> {

NodeApp/src/commander/assignment/subcommands/correction/subcommands/AssignmentCorrectionUnlinkCommand.ts

+import Assignment         from '../../../../../sharedByClients/models/Assignment.js';
+import ora                from 'ora';
+import TextStyle          from '../../../../../types/TextStyle.js';
+import DojoBackendManager from '../../../../../managers/DojoBackendManager.js';
+import SessionManager     from '../../../../../managers/SessionManager.js';
+import CommanderCommand   from '../../../../CommanderCommand.js';
+
+
+class AssignmentCorrectionLinkCommand extends CommanderCommand {
+    protected commandName: string = 'unlink';
+
+    protected defineCommand() {
+        this.command
+            .description('remove a correction of an assignment')
+            .argument('<string>', 'id or url of the exercise that is the correction')
+            .requiredOption('-a, --assignment <string>', 'id or url of the assignment of the correction')
+            .action(this.commandAction.bind(this));
+    }
+
+    protected async commandAction(exerciseIdOrUrl: string, options: { assignment: string }): Promise<void> {
+        let assignment!: Assignment | undefined;
+
+        // Check access
+        {
+            console.log(TextStyle.BLOCK('Please wait while we check access...'));
+
+            const assignmentGetSpinner: ora.Ora = ora('Checking if assignment exists').start();
+            assignment = await DojoBackendManager.getAssignment(options.assignment);
+            if ( !assignment ) {
+                assignmentGetSpinner.fail(`The assignment doesn't exists`);
+                return;
+            }
+            assignmentGetSpinner.succeed(`The assignment exists`);
+
+
+            const assignmentAccessSpinner: ora.Ora = ora('Checking assignment access').start();
+            if ( assignment.staff.find(staff => staff.id === SessionManager.profile?.id) === undefined ) {
+                assignmentAccessSpinner.fail(`You are not in the staff of the assignment`);
+                return;
+            }
+            assignmentAccessSpinner.succeed(`You are in the staff of the assignment`);
+        }
+
+        // Link the exercise
+        {
+            console.log(TextStyle.BLOCK('Please wait while we unlink the exercise...'));
+
+            await DojoBackendManager.unlinkCorrection(exerciseIdOrUrl, assignment);
+        }
+    }
+}
+
+
+export default new AssignmentCorrectionLinkCommand();
\ No newline at end of file

NodeApp/src/managers/DojoBackendManager.ts

@@ -224,6 +224,31 @@ class DojoBackendManager {
             return false;
         }
     }
+
+    public async unlinkCorrection(exerciseIdOrUrl: string, assignment: Assignment, verbose: boolean = true): Promise<boolean> {
+        const spinner: ora.Ora = ora(`Unlinking correction`);
+
+        if ( verbose ) {
+            spinner.start();
+        }
+
+        try {
+            await axios.delete(DojoBackendHelper.getApiUrl(ApiRoute.ASSIGNMENT_CORRECTION_UPDATE_DELETE, {
+                assignmentNameOrUrl: assignment.name,
+                exerciseIdOrUrl    : exerciseIdOrUrl
+            }));
+
+            if ( verbose ) {
+                spinner.succeed(`Correction unlinked`);
+            }
+
+            return true;
+        } catch ( error ) {
+            this.handleApiError(error, spinner, verbose, `Correction unlink error: ${ error }`);
+
+            return false;
+        }
+    }
 }