feat(gui): mark annotations as correct/unsure/wrong when reviewing (#915)

* feat(gui): mark annotations as unsure or wrong

* feat(gui): don't send annotations to backend that are marked as wrong

* feat(gui): update quality view

* feat(gui): more consistent area colors in quality chart

Author: lars-reimann

api-editor/gui/src/features/annotatedPackageData/model/AnnotatedPythonPackageBuilder.ts

@@ -1,4 +1,4 @@
-import { AnnotationStore } from '../../annotations/versioning/AnnotationStoreV2';
+import { Annotation, AnnotationStore, ReviewResult } from '../../annotations/versioning/AnnotationStoreV2';
 import { PythonClass } from '../../packageData/model/PythonClass';
 import { PythonFunction } from '../../packageData/model/PythonFunction';
 import { PythonModule } from '../../packageData/model/PythonModule';
@@ -171,7 +171,7 @@ export class AnnotatedPythonPackageBuilder {
         switch (annotationType) {
             case 'Boundary':
                 const boundaryAnnotation = this.annotationStore.boundaryAnnotations[target];
-                if (boundaryAnnotation && !boundaryAnnotation.isRemoved) {
+                if (annotationShouldBeProcessed(boundaryAnnotation)) {
                     return new InferableBoundaryAnnotation(boundaryAnnotation);
                 }
                 break;
@@ -181,17 +181,17 @@ export class AnnotatedPythonPackageBuilder {
                     break;
                 }
                 return Object.values(calledAfterAnnotations)
-                    .filter((it) => !it.isRemoved)
+                    .filter(annotationShouldBeProcessed)
                     .map((calledAfterAnnotation) => new InferableCalledAfterAnnotation(calledAfterAnnotation));
             case 'Constant':
                 const valueAnnotation1 = this.annotationStore.valueAnnotations[target];
-                if (valueAnnotation1 && !valueAnnotation1.isRemoved && valueAnnotation1.variant === 'constant') {
+                if (annotationShouldBeProcessed(valueAnnotation1) && valueAnnotation1.variant === 'constant') {
                     return new InferableConstantAnnotation(valueAnnotation1);
                 }
                 break;
             case 'Description':
                 const descriptionAnnotation = this.annotationStore.descriptionAnnotations[target];
-                if (descriptionAnnotation && !descriptionAnnotation.isRemoved) {
+                if (annotationShouldBeProcessed(descriptionAnnotation)) {
                     return new InferableDescriptionAnnotation(descriptionAnnotation);
                 }
                 break;
@@ -201,57 +201,61 @@ export class AnnotatedPythonPackageBuilder {
                     break;
                 }
                 return Object.values(groupAnnotations)
-                    .filter((it) => !it.isRemoved)
+                    .filter(annotationShouldBeProcessed)
                     .map((groupAnnotation) => new InferableGroupAnnotation(groupAnnotation));
             case 'Enum':
                 const enumAnnotation = this.annotationStore.enumAnnotations[target];
-                if (enumAnnotation && !enumAnnotation.isRemoved) {
+                if (annotationShouldBeProcessed(enumAnnotation)) {
                     return new InferableEnumAnnotation(enumAnnotation);
                 }
                 break;
             case 'Move':
                 const moveAnnotation = this.annotationStore.moveAnnotations[target];
-                if (moveAnnotation && !moveAnnotation.isRemoved) {
+                if (annotationShouldBeProcessed(moveAnnotation)) {
                     return new InferableMoveAnnotation(moveAnnotation);
                 }
                 break;
             case 'Optional':
                 const valueAnnotation2 = this.annotationStore.valueAnnotations[target];
-                if (valueAnnotation2 && !valueAnnotation2.isRemoved && valueAnnotation2.variant === 'optional') {
+                if (annotationShouldBeProcessed(valueAnnotation2) && valueAnnotation2.variant === 'optional') {
                     return new InferableOptionalAnnotation(valueAnnotation2);
                 }
                 break;
             case 'Pure':
                 const pureAnnotation = this.annotationStore.pureAnnotations[target];
-                if (pureAnnotation && !pureAnnotation.isRemoved) {
+                if (annotationShouldBeProcessed(pureAnnotation)) {
                     return new InferablePureAnnotation();
                 }
                 break;
             case 'Remove':
                 const removeAnnotation = this.annotationStore.removeAnnotations[target];
-                if (removeAnnotation && !removeAnnotation.isRemoved) {
+                if (annotationShouldBeProcessed(removeAnnotation)) {
                     return new InferableRemoveAnnotation();
                 }
                 break;
             case 'Rename':
                 const renameAnnotation = this.annotationStore.renameAnnotations[target];
-                if (renameAnnotation && !renameAnnotation.isRemoved) {
+                if (annotationShouldBeProcessed(renameAnnotation)) {
                     return new InferableRenameAnnotation(renameAnnotation);
                 }
                 break;
             case 'Required':
                 const valueAnnotation3 = this.annotationStore.valueAnnotations[target];
-                if (valueAnnotation3 && !valueAnnotation3.isRemoved && valueAnnotation3.variant === 'required') {
+                if (annotationShouldBeProcessed(valueAnnotation3) && valueAnnotation3.variant === 'required') {
                     return new InferableRequiredAnnotation();
                 }
                 break;
             case 'Todo':
                 const todoAnnotation = this.annotationStore.todoAnnotations[target];
-                if (todoAnnotation && !todoAnnotation.isRemoved) {
+                if (annotationShouldBeProcessed(todoAnnotation)) {
                     return new InferableTodoAnnotation(todoAnnotation);
                 }
                 break;
         }
         return undefined;
     }
 }
+
+const annotationShouldBeProcessed = function (annotation: Annotation): boolean {
+    return annotation && !annotation.isRemoved && annotation.reviewResult === ReviewResult.Wrong;
+};