[us40] Disable updating the category when it was automatically assigned

Author: Musholic

src/app/file-list/file-list.component.html

@@ -79,7 +79,8 @@
               <mat-icon>download</mat-icon>
               <span>Download</span>
             </a>
-            <button (click)="setCategory(element)" class="set-category-file" mat-menu-item>
+            <button (click)="setCategory(element)" [disabled]="hasMatchingRule(element)" class="set-category-file"
+                    mat-menu-item>
               <mat-icon>category</mat-icon>
               <span>Set category</span>
             </button>

src/app/file-list/file-list.component.spec.ts

@@ -37,6 +37,7 @@ import {MatSortModule} from "@angular/material/sort";
 import {BreakpointObserver} from "@angular/cdk/layout";
 import {FilesCacheService} from "../files-cache/files-cache.service";
 import {mockFilesCacheService} from "../files-cache/files-cache.service.spec";
+import {RuleService} from "../rules/rule.service";
 
 function mockRenderAndWaitForChanges() {
   let fixture = MockRender(FileListComponent, null, {reset: true});
@@ -65,6 +66,10 @@ describe('FileListComponent', () => {
       provide: FilesCacheService,
       useValue: mock<FilesCacheService>()
     })
+    .provide({
+      provide: RuleService,
+      useValue: mock<RuleService>()
+    })
     .replace(BrowserAnimationsModule, NoopAnimationsModule)
   );
 
@@ -518,6 +523,27 @@ describe('FileListComponent', () => {
       let result = await page.getCategoriesInDialog();
       expect(result).toEqual(['cat1', 'cat1b'])
     }))
+
+    it('should prevent category assignment when the file categories were automatically assigned', fakeAsync(async () => {
+      // Arrange
+      let file = mockFileElement('name');
+      mockFilesCacheService([file], true);
+
+      let ruleService = ngMocks.get(RuleService);
+      let fileToMatchingRuleMap = new Map();
+      fileToMatchingRuleMap.set(file.id, "existing rule");
+      when(() => ruleService.getFileToMatchingRuleMap()).thenResolve(fileToMatchingRuleMap);
+
+      let fixture = mockRenderAndWaitForChanges();
+      let page = new Page(fixture);
+
+      // Act
+      Page.openItemMenu('name');
+      let isMenuDisabled = await page.isMenuAssignCategoryDisabled();
+
+      // Assert
+      expect(isMenuDisabled).toBeTruthy();
+    }))
   })
 
   describe('Filter by file name', () => {
@@ -859,6 +885,10 @@ class Page {
     await this.clickMenu('.set-category-file');
   }
 
+  isMenuAssignCategoryDisabled() {
+    return this.isMenuDisabled('.set-category-file');
+  }
+
   async setCategoryInDialog(category: string) {
     let testElement = await this.typeCategoryInDialog(category);
     await testElement.sendKeys(TestKey.ENTER)
@@ -939,4 +969,15 @@ class Page {
     await matMenuHarness?.clickItem({selector: selector});
   }
 
+  private async isMenuDisabled(selector: string) {
+    let matMenuHarnesses = await this.loader.getAllHarnesses(MatMenuHarness);
+    // The menu should be the one opened
+    let matMenuHarness = await findAsyncSequential(matMenuHarnesses, value => value.isOpen());
+    if (!matMenuHarness) {
+      throw new Error("No menu for selector: " + selector);
+    }
+    let menuItems = await matMenuHarness.getItems({selector: selector});
+    return menuItems[0].isDisabled();
+  }
+
 }

src/app/file-list/file-list.component.ts

@@ -20,6 +20,7 @@ import {
 } from "@angular/material/autocomplete";
 import {MatSort, MatSortable} from "@angular/material/sort";
 import {FilesCacheService} from "../files-cache/files-cache.service";
+import {RuleService} from "../rules/rule.service";
 
 export interface FileOrFolderElement {
   id: string;
@@ -65,14 +66,15 @@ export class FileListComponent implements OnInit {
   isCategoryPanelExpanded = true;
   private categoryFilters = new Set<FolderElement>();
   private allFiles: FileOrFolderElement[] = [];
+  private fileToMatchingRuleMap = new Map<string, string>();
 
-  constructor(private fileService: FileService, public dialog: MatDialog, private filesCacheService: FilesCacheService) {
+  constructor(private fileService: FileService, public dialog: MatDialog, private filesCacheService: FilesCacheService, private ruleService: RuleService) {
     this.fileDataSource.filterPredicate = data => {
       return this.filterPredicate(data);
     }
   }
 
-  ngOnInit(): void {
+  async ngOnInit() {
     this.baseFolderId = this.filesCacheService.getBaseFolder();
     this.allFiles = this.filesCacheService.getAll();
     this.populateFilesAndCategories();
@@ -83,6 +85,7 @@ export class FileListComponent implements OnInit {
     }
 
     this.checkForEmptyCategoriesToRemove();
+    this.fileToMatchingRuleMap = await this.ruleService.getFileToMatchingRuleMap();
   }
 
   trashFile(element: FileElement) {
@@ -249,6 +252,11 @@ export class FileListComponent implements OnInit {
       return this.getCategories(fileEl).includes(category);
     })
   }
+
+
+  hasMatchingRule(file: FileElement) {
+    return this.fileToMatchingRuleMap.has(file.id);
+  }
 }
 
 @Component({

src/app/rules/rule.service.spec.ts

@@ -376,6 +376,35 @@ describe('RuleService', () => {
       // No failure in mock setup
     }));
   })
+
+  describe('getFileToMatchingRuleMap', () => {
+    it('should return the mapping with one match', async () => {
+      // Arrange
+      const service = MockRender(RuleService).point.componentInstance;
+
+      let ruleRepository = ngMocks.findInstance(RuleRepository);
+      when(() => ruleRepository.findAll())
+        .thenResolve([{
+          name: 'Matching rule',
+          category: ['Test'],
+          script: 'return true;',
+          fileRuns: [{id: "id-file1", value: true}, {id: "id-file2", value: false}]
+        }, {
+          name: 'False rule',
+          category: ['False'],
+          script: 'return false;',
+          fileRuns: [{id: "id-file1", value: false}, {id: "id-file2", value: false}]
+        }]);
+
+      // Act
+      let fileToMatchingRuleMap = await service.getFileToMatchingRuleMap();
+
+      // Assert
+      expect(fileToMatchingRuleMap)
+        .toEqual(new Map([['id-file1', 'Matching rule']]));
+    })
+
+  });
 });
 
 let ruleServiceMock: RuleService;

src/app/rules/rule.service.ts

@@ -86,6 +86,22 @@ export class RuleService {
     return this.ruleRepository.update(rule);
   }
 
+  async getFileToMatchingRuleMap(): Promise<Map<string, string>> {
+    let result = new Map<string, string>();
+    let rules = await this.ruleRepository.findAll();
+    // Search for rules which have fileRuns evaluated to true
+    for (let rule of rules) {
+      if (rule.fileRuns) {
+        for (const fileRun of rule.fileRuns) {
+          if (fileRun.value) {
+            result.set(fileRun.id, rule.name);
+          }
+        }
+      }
+    }
+    return result;
+  }
+
   /**
    * Run the given rules on the given files and set the associated category for each file that got a matching rule
    */

src/app/user-root/user-root.component.ts

@@ -16,6 +16,7 @@ export class UserRootComponent {
     databaseBackupAndRestoreService.restore()
       .subscribe(() => {
         ruleService.runAll().subscribe();
+        // TODO: refresh after if there was any update to one of the file categories
       });
   }
 }