SF-3613 Allow old drafts to open draft tab without formatting options

Author: Nateowami

src/SIL.XForge.Scripture/ClientApp/src/app/translate/draft-generation/draft-history-list/draft-history-entry/draft-history-entry.component.spec.ts

@@ -83,7 +83,7 @@ describe('DraftHistoryEntryComponent', () => {
     when(mockedTrainingDataService.queryTrainingDataAsync(anything(), anything())).thenResolve(
       instance(trainingDataQuery)
     );
-    when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected()).thenReturn(true);
+    when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected(anything())).thenReturn(true);
     fixture = TestBed.createComponent(DraftHistoryEntryComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
@@ -168,7 +168,7 @@ describe('DraftHistoryEntryComponent', () => {
     }));
 
     it('should show the USFM format option when the project is the latest draft', fakeAsync(() => {
-      when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected()).thenReturn(false);
+      when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected(anything())).thenReturn(false);
       when(mockedDraftOptionsService.areFormattingOptionsSupportedForBuild(anything())).thenReturn(true);
       const user = 'user-display-name';
       const date = dateAfterFormattingSupported;
@@ -241,7 +241,7 @@ describe('DraftHistoryEntryComponent', () => {
     }));
 
     it('should handle builds with additional info referencing a deleted user', fakeAsync(() => {
-      when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected()).thenReturn(false);
+      when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected(anything())).thenReturn(false);
       when(mockedDraftOptionsService.areFormattingOptionsSupportedForBuild(anything())).thenReturn(true);
       when(mockedI18nService.formatDate(anything())).thenReturn('formatted-date');
       when(mockedI18nService.formatAndLocalizeScriptureRange('GEN')).thenReturn('Genesis');
@@ -353,7 +353,7 @@ describe('DraftHistoryEntryComponent', () => {
     });
 
     it('should show set draft format UI', fakeAsync(() => {
-      when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected()).thenReturn(false);
+      when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected(anything())).thenReturn(false);
       when(mockedDraftOptionsService.areFormattingOptionsSupportedForBuild(anything())).thenReturn(true);
       const date = dateAfterFormattingSupported;
       component.entry = {

src/SIL.XForge.Scripture/ClientApp/src/app/translate/draft-generation/draft-options.service.spec.ts

@@ -45,6 +45,16 @@ describe('DraftOptionsService', () => {
     return doc;
   }
 
+  function buildDtoWithDate(date: Date): BuildDto {
+    return {
+      additionalInfo: {
+        dateFinished: date.toJSON()
+      }
+    } as BuildDto;
+  }
+
+  const SUPPORTED_BUILD_ENTRY: BuildDto = buildDtoWithDate(new Date(FORMATTING_OPTIONS_SUPPORTED_DATE.getTime() + 1));
+
   const PROJECT_DOC_BOTH_FORMATS: SFProjectProfileDoc = buildProjectDoc({
     paragraphFormat: ParagraphBreakFormat.BestGuess,
     quoteFormat: QuoteFormat.Normalized
@@ -83,23 +93,28 @@ describe('DraftOptionsService', () => {
   describe('areFormattingOptionsAvailableButUnselected', () => {
     it('returns true when flag enabled and both options missing', () => {
       when(mockedActivatedProject.projectDoc).thenReturn(PROJECT_DOC_EMPTY_USFM);
-      expect(service.areFormattingOptionsAvailableButUnselected()).toBe(true);
+      expect(service.areFormattingOptionsAvailableButUnselected(SUPPORTED_BUILD_ENTRY)).toBe(true);
     });
 
     it('returns true when flag enabled and one option missing', () => {
       when(mockedActivatedProject.projectDoc).thenReturn(PROJECT_DOC_QUOTE_ONLY);
-      expect(service.areFormattingOptionsAvailableButUnselected()).toBe(true);
+      expect(service.areFormattingOptionsAvailableButUnselected(SUPPORTED_BUILD_ENTRY)).toBe(true);
     });
 
     it('returns false when flag enabled and both options set', () => {
       when(mockedActivatedProject.projectDoc).thenReturn(PROJECT_DOC_BOTH_FORMATS);
-      expect(service.areFormattingOptionsAvailableButUnselected()).toBe(false);
+      expect(service.areFormattingOptionsAvailableButUnselected(SUPPORTED_BUILD_ENTRY)).toBe(false);
     });
 
     it('returns false when flag disabled', () => {
       when(mockedFeatureFlagService.usfmFormat).thenReturn(createTestFeatureFlag(false));
       when(mockedActivatedProject.projectDoc).thenReturn(PROJECT_DOC_EMPTY_USFM);
-      expect(service.areFormattingOptionsAvailableButUnselected()).toBe(false);
+      expect(service.areFormattingOptionsAvailableButUnselected(SUPPORTED_BUILD_ENTRY)).toBe(false);
+    });
+
+    it('returns false when build entry unavailable', () => {
+      when(mockedActivatedProject.projectDoc).thenReturn(PROJECT_DOC_EMPTY_USFM);
+      expect(service.areFormattingOptionsAvailableButUnselected(undefined)).toBe(false);
     });
   });
 
@@ -109,7 +124,7 @@ describe('DraftOptionsService', () => {
       if (date == null) {
         return { additionalInfo: {} } as BuildDto;
       }
-      return { additionalInfo: { dateFinished: date.toJSON() } } as BuildDto;
+      return buildDtoWithDate(date);
     }
 
     it('returns true when flag enabled and date after supported date', () => {

src/SIL.XForge.Scripture/ClientApp/src/app/translate/draft-generation/draft-options.service.ts

@@ -23,12 +23,12 @@ export class DraftOptionsService {
     );
   }
 
-  areFormattingOptionsAvailableButUnselected(): boolean {
-    return (
-      this.featureFlags.usfmFormat.enabled &&
-      (this.activatedProjectService.projectDoc?.data?.translateConfig.draftConfig.usfmConfig?.paragraphFormat == null ||
-        this.activatedProjectService.projectDoc?.data?.translateConfig.draftConfig.usfmConfig?.quoteFormat == null)
-    );
+  areFormattingOptionsAvailableButUnselected(draftBuild: BuildDto | undefined): boolean {
+    const usfmConfig = this.activatedProjectService.projectDoc?.data?.translateConfig.draftConfig.usfmConfig;
+    const optionsSelected = usfmConfig?.paragraphFormat != null && usfmConfig?.quoteFormat != null;
+
+    const available = this.featureFlags.usfmFormat.enabled && this.areFormattingOptionsSupportedForBuild(draftBuild);
+    return available && !optionsSelected;
   }
 
   areFormattingOptionsSupportedForBuild(entry: BuildDto | undefined): boolean {

src/SIL.XForge.Scripture/ClientApp/src/app/translate/editor/editor.component.spec.ts

@@ -4111,8 +4111,8 @@ describe('EditorComponent', () => {
           Object.defineProperty(env.component, 'showSource', { get: () => true });
         });
         env.setupProject({ translateConfig: { draftConfig: {} } });
-        // Formatting options not selected, so draft tab should not be shown
-        when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected()).thenReturn(true);
+        // Formatting options not selected, so draft tab should be blocked
+        when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected(anything())).thenReturn(true);
         when(mockedPermissionsService.canAccessDrafts(anything(), anything())).thenReturn(true);
         env.wait();
         env.routeWithParams({ projectId: 'project01', bookId: 'LUK', chapter: '1' });
@@ -4903,6 +4903,8 @@ class TestEnvironment {
     ).thenReturn(of([]));
     when(mockedDraftGenerationService.getGeneratedDraftHistory(anything(), anything(), anything())).thenReturn(of([]));
     when(mockedDraftGenerationService.draftExists(anything(), anything(), anything())).thenReturn(of(true));
+    when(mockedDraftGenerationService.getLastCompletedBuild(anything())).thenReturn(of({} as BuildDto));
+    when(mockedDraftOptionsService.areFormattingOptionsAvailableButUnselected(anything())).thenReturn(false);
     when(mockedPermissionsService.isUserOnProject(anything())).thenResolve(true);
     when(mockedFeatureFlagService.newDraftHistory).thenReturn(createTestFeatureFlag(false));
     when(mockedLynxWorkspaceService.rawInsightSource$).thenReturn(of([]));

src/SIL.XForge.Scripture/ClientApp/src/app/translate/editor/editor.component.ts

@@ -1490,20 +1490,25 @@ export class EditorComponent extends DataLoadingComponent implements OnDestroy,
       this.projectDoc,
       this.userService.currentUserId
     );
-    if (
-      ((hasDraft && !draftApplied) || urlDraftActive) &&
-      canViewDrafts &&
-      !this.draftOptionsService.areFormattingOptionsAvailableButUnselected()
-    ) {
+
+    const hasUnappliedDraft: boolean = hasDraft && !draftApplied;
+    const draftShouldBeVisible: boolean = hasUnappliedDraft || urlDraftActive;
+
+    let draftBuild: BuildDto | undefined;
+    // Only try to fetch the draft build if existing information indicates we should show the draft
+    if (draftShouldBeVisible && canViewDrafts && this.projectId != null) {
+      draftBuild = await firstValueFrom(this.draftGenerationService.getLastCompletedBuild(this.projectId));
+    }
+
+    const isBlockedByFormattingOptions: boolean =
+      this.draftOptionsService.areFormattingOptionsAvailableButUnselected(draftBuild);
+
+    if (draftShouldBeVisible && canViewDrafts && draftBuild != null && !isBlockedByFormattingOptions) {
       // URL may indicate to select the 'draft' tab (such as when coming from generate draft page)
       const groupIdToAddTo: EditorTabGroupType = this.showSource ? 'source' : 'target';
 
       // Add to 'source' (or 'target' if showSource is false) tab group if no existing draft tab
       if (existingDraftTab == null) {
-        const draftBuild: BuildDto | undefined = await firstValueFrom(
-          this.draftGenerationService.getLastCompletedBuild(this.projectId!)
-        );
-
         this.tabState.addTab(
           groupIdToAddTo,
           this.editorTabFactory.createTab('draft', {

src/SIL.XForge.Scripture/ClientApp/src/app/translate/editor/tabs/editor-tab-menu.service.spec.ts

@@ -16,6 +16,7 @@ import { SFProjectProfileDoc } from '../../../core/models/sf-project-profile-doc
 import { SF_TYPE_REGISTRY } from '../../../core/models/sf-type-registry';
 import { PermissionsService } from '../../../core/permissions.service';
 import { TabStateService } from '../../../shared/sf-tab-group';
+import { DraftGenerationService } from '../../draft-generation/draft-generation.service';
 import { DraftOptionsService } from '../../draft-generation/draft-options.service';
 import { EditorTabMenuService } from './editor-tab-menu.service';
 import { EditorTabInfo } from './editor-tabs.types';
@@ -26,6 +27,7 @@ const tabStateMock: TabStateService<any, any> = mock(TabStateService);
 const mockUserService = mock(UserService);
 const mockPermissionsService = mock(PermissionsService);
 const mockDraftOptionsService = mock(DraftOptionsService);
+const mockDraftGenerationService = mock(DraftGenerationService);
 
 describe('EditorTabMenuService', () => {
   configureTestingModule(() => ({
@@ -37,7 +39,8 @@ describe('EditorTabMenuService', () => {
       { provide: UserService, useMock: mockUserService },
       { provide: PermissionsService, useMock: mockPermissionsService },
       { provide: OnlineStatusService, useClass: TestOnlineStatusService },
-      { provide: DraftOptionsService, useMock: mockDraftOptionsService }
+      { provide: DraftOptionsService, useMock: mockDraftOptionsService },
+      { provide: DraftGenerationService, useMock: mockDraftGenerationService }
     ]
   }));
 
@@ -253,7 +256,7 @@ describe('EditorTabMenuService', () => {
   it('should not show draft menu item when draft formatting (usfmConfig) is not set', done => {
     const env = new TestEnvironment();
     // Simulate formatting options available but still unselected, so draft tab should be hidden
-    when(mockDraftOptionsService.areFormattingOptionsAvailableButUnselected()).thenReturn(true);
+    when(mockDraftOptionsService.areFormattingOptionsAvailableButUnselected(anything())).thenReturn(true);
     env.setExistingTabs([]);
     service['canShowHistory'] = () => true;
     service['canShowResource'] = () => true;
@@ -307,6 +310,10 @@ class TestEnvironment {
   constructor(explicitProjectDoc?: SFProjectProfileDoc) {
     const projectDoc: SFProjectProfileDoc = explicitProjectDoc ?? this.projectDoc;
     when(activatedProjectMock.projectDoc$).thenReturn(of(projectDoc));
+    when(activatedProjectMock.projectId$).thenReturn(of(projectDoc.id));
+    when(tabStateMock.tabs$).thenReturn(of([] as EditorTabInfo[]));
+    when(mockDraftGenerationService.getLastCompletedBuild(anything())).thenReturn(of(undefined));
+    when(mockDraftOptionsService.areFormattingOptionsAvailableButUnselected(anything())).thenReturn(false);
     when(mockUserService.currentUserId).thenReturn('user01');
     when(mockPermissionsService.canAccessDrafts(anything(), anything())).thenReturn(true);
     service = TestBed.inject(EditorTabMenuService);

src/SIL.XForge.Scripture/ClientApp/src/app/translate/editor/tabs/editor-tab-menu.service.ts

@@ -16,12 +16,18 @@ import { SFProjectProfileDoc } from '../../../core/models/sf-project-profile-doc
 import { ParatextService } from '../../../core/paratext.service';
 import { PermissionsService } from '../../../core/permissions.service';
 import { SFProjectService } from '../../../core/sf-project.service';
+import { BuildDto } from '../../../machine-api/build-dto';
 import { TabMenuItem, TabMenuService, TabStateService } from '../../../shared/sf-tab-group';
+import { FlatTabInfo } from '../../../shared/sf-tab-group/tab-state/tab-state.service';
+import { DraftGenerationService } from '../../draft-generation/draft-generation.service';
 import { DraftOptionsService } from '../../draft-generation/draft-options.service';
 import { EditorTabInfo } from './editor-tabs.types';
+
 @Injectable()
 export class EditorTabMenuService implements TabMenuService<EditorTabGroupType> {
-  private readonly menuItems$: Observable<TabMenuItem[]> = this.initMenuItems();
+  private readonly menuItems$: Observable<TabMenuItem[]>;
+  // TODO: Detect when a new draft build is available so we can update the latest build
+  private readonly latestDraftBuild$: Observable<BuildDto | undefined>;
 
   constructor(
     private readonly destroyRef: DestroyRef,
@@ -31,30 +37,49 @@ export class EditorTabMenuService implements TabMenuService<EditorTabGroupType>
     private readonly tabState: TabStateService<EditorTabGroupType, EditorTabInfo>,
     private readonly permissionsService: PermissionsService,
     private readonly i18n: I18nService,
-    private readonly draftOptionsService: DraftOptionsService
-  ) {}
+    private readonly draftOptionsService: DraftOptionsService,
+    private readonly draftGenerationService: DraftGenerationService
+  ) {
+    this.latestDraftBuild$ = this.initLatestDraftBuild();
+    this.menuItems$ = this.initMenuItems();
+  }
 
   getMenuItems(): Observable<TabMenuItem[]> {
     // Return the same menu items for all tab groups
     return this.menuItems$;
   }
 
+  private initLatestDraftBuild(): Observable<BuildDto | undefined> {
+    return this.activatedProject.projectId$.pipe(
+      switchMap(projectId => {
+        if (projectId == null) {
+          return of(undefined);
+        }
+
+        const build$ = this.draftGenerationService.getLastCompletedBuild(projectId);
+        return build$ == null ? of(undefined) : build$;
+      })
+    );
+  }
+
   private initMenuItems(): Observable<TabMenuItem[]> {
     return combineLatest([
       this.activatedProject.projectDoc$.pipe(filterNullish()),
-      this.onlineStatus.onlineStatus$
+      this.onlineStatus.onlineStatus$,
+      this.latestDraftBuild$
     ]).pipe(
       quietTakeUntilDestroyed(this.destroyRef),
-      switchMap(([projectDoc, isOnline]) => {
-        return combineLatest([of(projectDoc), of(isOnline), this.tabState.tabs$]);
+      switchMap(([projectDoc, isOnline, latestDraftBuild]) => {
+        const tabs$: Observable<FlatTabInfo<EditorTabGroupType, EditorTabInfo>[]> = this.tabState.tabs$ ?? of([]);
+        return combineLatest([of(projectDoc), of(isOnline), tabs$, of(latestDraftBuild)]);
       }),
-      switchMap(([projectDoc, isOnline, existingTabs]) => {
+      switchMap(([projectDoc, isOnline, existingTabs, latestDraftBuild]) => {
         const showDraft =
           isOnline &&
           projectDoc.data != null &&
           SFProjectService.hasDraft(projectDoc.data) &&
           this.permissionsService.canAccessDrafts(projectDoc, this.userService.currentUserId) &&
-          !this.draftOptionsService.areFormattingOptionsAvailableButUnselected();
+          !this.draftOptionsService.areFormattingOptionsAvailableButUnselected(latestDraftBuild);
         const items: Observable<TabMenuItem>[] = [];
 
         for (const tabType of editorTabTypes) {