Prefer Archivematica access copies over older ones

src/app/file-browser/components/download-button/download-button.component.ts

@@ -78,19 +78,9 @@
 
   displayDownloadOptions() {
     this.displayDownloadDropdown = true;
-    const original = (this.selectedItem as RecordVO).FileVOs?.find(
-      (item) => item.format === 'file.format.original',
-    );
-    const converted = (this.selectedItem as RecordVO).FileVOs?.filter(
-      (item) => item.format === 'file.format.converted',
-    ).map((item) => ({
-      name: item.type,
-      extension: item.type.split('.').pop(),
-    }));
-    this.downloadOptions = [
-      { name: original?.type, extension: original?.type.split('.').pop() },
-      ...converted,
-    ];
+    this.downloadOptions = (
+      this.selectedItem as RecordVO
+    ).getDownloadOptionsList();
   }
 
   bringDropdownIntoView() {

src/app/file-browser/components/file-list-controls/file-list-controls.component.ts

@@ -494,19 +494,8 @@
 
   displayDownloadOptions() {
     this.displayDownloadDropdown = true;
-    const original = (this.selectedItems[0] as RecordVO).FileVOs?.find(
-      (item) => item.format === 'file.format.original',
-    );
-    const converted = (this.selectedItems[0] as RecordVO).FileVOs?.filter(
-      (item) => item.format === 'file.format.converted',
-    ).map((item) => ({
-      name: item.type,
-      extension: item.type.split('.').pop(),
-    }));
-
-    this.downloadOptions = [
-      { name: original?.type, extension: original?.type.split('.').pop() },
-      ...converted,
-    ];
+    this.downloadOptions = (
+      this.selectedItems[0] as RecordVO
+    ).getDownloadOptionsList();
   }
 }

src/app/file-browser/components/file-viewer/file-viewer.component.ts

@@ -25,6 +25,8 @@ import type { KeysOfType } from '@shared/utilities/keysoftype';
 import { Subscription } from 'rxjs';
 import { SearchService } from '@search/services/search.service';
 import { ZoomingImageViewerComponent } from '@shared/components/zooming-image-viewer/zooming-image-viewer.component';
+import { FileFormat } from '@models/file-vo';
+import { GetAccessFile } from '@models/get-access-file';
 import { TagsService } from '../../../core/services/tags/tags.service';
 
 @Component({
@@ -194,9 +196,11 @@ export class FileViewerComponent implements OnInit, OnDestroy {
     this.isZoomableImage =
       this.currentRecord.type.includes('image') &&
       this.currentRecord.FileVOs?.length &&
-      ZoomingImageViewerComponent.chooseFullSizeImage(this.currentRecord);
+      typeof ZoomingImageViewerComponent.chooseFullSizeImage(
+        this.currentRecord,
+      ) !== 'undefined';
     this.isDocument = this.currentRecord.FileVOs?.some(
-      (obj: ItemVO) => obj.type.includes('pdf') || obj.type.includes('txt'),
+      (obj) => obj.type.includes('pdf') || obj.type.includes('txt'),
     );
     this.documentUrl = this.getDocumentUrl();
     this.setCurrentTags();
@@ -215,19 +219,17 @@ export class FileViewerComponent implements OnInit, OnDestroy {
       return false;
     }
 
-    const original = find(this.currentRecord.FileVOs, {
-      format: 'file.format.original',
-    }) as any;
-    const pdf = find(this.currentRecord.FileVOs, (f) =>
-      f.type.includes('pdf'),
-    ) as any;
+    const original = this.currentRecord.FileVOs.find(
+      (file) => file.format === FileFormat.Original,
+    );
+    const access = GetAccessFile(this.currentRecord);
 
     let url;
 
     if (original?.type.includes('pdf') || original?.type.includes('txt')) {
       url = original?.fileURL;
-    } else if (pdf) {
-      url = pdf?.fileURL;
+    } else if (access) {
+      url = access?.fileURL;
     }
 
     if (!url) {

src/app/models/file-vo.ts

@@ -0,0 +1,15 @@
+export const enum FileFormat {
+  Original = 'file.format.original',
+  Converted = 'file.format.converted',
+  ArchivematicaAccess = 'file.format.archivematica.access',
+}
+
+export interface PermanentFile {
+  fileId: number;
+  size: number;
+  format: FileFormat;
+  parentFileId?: number;
+  fileURL: string;
+  downloadURL: string;
+  type: string;
+}

src/app/models/get-access-file.spec.ts

@@ -0,0 +1,87 @@
+/* @format */
+import { FileFormat, PermanentFile } from './file-vo';
+import { GetAccessFile, HasFiles } from './get-access-file';
+
+describe('GetAccessFile', () => {
+  function makeTestFile(params: Partial<PermanentFile> = {}): PermanentFile {
+    return Object.assign(
+      {
+        fileId: 0,
+        size: 0,
+        format: FileFormat.Original,
+        fileURL: 'test',
+        downloadURL: 'test',
+        type: 'test',
+      },
+      params,
+    );
+  }
+
+  it('should return null for an undefined object being passed in', () => {
+    let files: HasFiles;
+
+    expect(GetAccessFile(files)).toBeFalsy();
+  });
+
+  it('should return null for an object with no FileVOs', () => {
+    expect(GetAccessFile({ FileVOs: [] })).toBeFalsy();
+  });
+
+  it('should return the only given FileVO', () => {
+    expect(
+      GetAccessFile({
+        FileVOs: [makeTestFile()],
+      }),
+    ).toEqual(makeTestFile());
+  });
+
+  it('should prefer archivematica access copies every time', () => {
+    const archivematicaFile = makeTestFile({
+      format: FileFormat.ArchivematicaAccess,
+      fileId: 1,
+    });
+
+    expect(
+      GetAccessFile({
+        FileVOs: [
+          makeTestFile(),
+          makeTestFile({ format: FileFormat.Converted }),
+          archivematicaFile,
+          makeTestFile(),
+          makeTestFile({ format: FileFormat.Converted }),
+        ],
+      }),
+    ).toEqual(archivematicaFile);
+  });
+
+  it('should prefer converted copies to original files', () => {
+    const convertedFile = makeTestFile({
+      format: FileFormat.Converted,
+      fileId: 1,
+    });
+
+    expect(
+      GetAccessFile({
+        FileVOs: [makeTestFile(), convertedFile, makeTestFile()],
+      }),
+    ).toEqual(convertedFile);
+  });
+
+  it('should prefer pdf converted copies to other converted formats', () => {
+    const convertedFile = makeTestFile({
+      format: FileFormat.Converted,
+      fileId: 1,
+      type: 'type.file.pdf.pdfa',
+    });
+
+    expect(
+      GetAccessFile({
+        FileVOs: [
+          makeTestFile(),
+          makeTestFile({ format: FileFormat.Converted, fileId: 2 }),
+          convertedFile,
+        ],
+      }),
+    ).toEqual(convertedFile);
+  });
+});

src/app/models/get-access-file.ts

@@ -0,0 +1,26 @@
+import { prioritizeIf } from '@root/utils/prioritize-if';
+import { FileFormat, PermanentFile } from './file-vo';
+
+export interface HasFiles {
+  FileVOs: PermanentFile[];
+}
+
+function getArchivematicaAccess(files: PermanentFile[]) {
+  return files.find((file) => file.format === FileFormat.ArchivematicaAccess);
+}
+
+function getPrioritizedConvertedFile(files: PermanentFile[]) {
+  return prioritizeIf(
+    files.filter((file) => file.format === FileFormat.Converted),
+    (file) => file.type.includes('pdf'),
+  )[0];
+}
+
+export function GetAccessFile(record: HasFiles): PermanentFile | undefined {
+  const files = record?.FileVOs ?? [];
+  return (
+    getArchivematicaAccess(files) ||
+    getPrioritizedConvertedFile(files) ||
+    files[0]
+  );
+}

src/app/models/record-vo.spec.ts

@@ -1,5 +1,6 @@
 /* @format */
 import { DataStatus } from './data-status.enum';
+import { FileFormat } from './file-vo';
 import { RecordVO, ShareVO } from '.';
 
 describe('RecordVO', () => {
@@ -105,4 +106,74 @@ describe('RecordVO', () => {
 
     expect(record.ShareVOs[0]).toBeInstanceOf(ShareVO);
   });
+
+  describe('Download options', () => {
+    it('returns an empty array for an empty record', () => {
+      const record = new RecordVO({});
+
+      expect(record.getDownloadOptionsList()).toEqual([]);
+    });
+
+    it('converts to download option format', () => {
+      const record = new RecordVO({});
+      record.FileVOs = [
+        {
+          format: FileFormat.Converted,
+          fileId: 0,
+          type: 'test.pdf',
+          fileURL: 'test',
+          downloadURL: 'test',
+          size: 0,
+        },
+        {
+          format: FileFormat.Converted,
+          fileId: 0,
+          type: 'test.odt',
+          fileURL: 'test',
+          downloadURL: 'test',
+          size: 0,
+        },
+      ];
+      const downloadOptions = record.getDownloadOptionsList();
+
+      expect(downloadOptions.length).toBe(2);
+      expect(downloadOptions[0].name).toBe('test.pdf');
+      expect(downloadOptions[0].extension).toBe('pdf');
+    });
+
+    it('prioritizes original before others', () => {
+      const record = new RecordVO({});
+      record.FileVOs = [
+        {
+          format: FileFormat.Converted,
+          fileId: 0,
+          type: 'test.pdf',
+          fileURL: 'test',
+          downloadURL: 'test',
+          size: 0,
+        },
+        {
+          format: FileFormat.Original,
+          fileId: 0,
+          type: 'test.docx',
+          fileURL: 'test',
+          downloadURL: 'test',
+          size: 0,
+        },
+        {
+          format: FileFormat.Converted,
+          fileId: 0,
+          type: 'test.odt',
+          fileURL: 'test',
+          downloadURL: 'test',
+          size: 0,
+        },
+      ];
+      const downloadOptions = record.getDownloadOptionsList();
+
+      expect(downloadOptions.length).toBe(3);
+      expect(downloadOptions[0].name).toBe('test.docx');
+      expect(downloadOptions[0].extension).toBe('docx');
+    });
+  });
 });

src/app/models/record-vo.ts

@@ -3,6 +3,7 @@ import { BaseVO, BaseVOData, DynamicListChild } from '@models/base-vo';
 import { DataStatus } from '@models/data-status.enum';
 import { ShareVO, sortShareVOs } from '@models/share-vo';
 import { formatDateISOString } from '@shared/utilities/dateTime';
+import { prioritizeIf } from '@root/utils/prioritize-if';
 import { AccessRoleType } from './access-role';
 import { TimezoneVOData } from './timezone-vo';
 import { ChildItemData, HasParentFolder } from './folder-vo';
@@ -11,6 +12,7 @@ import { LocnVOData } from './locn-vo';
 import { TagVOData } from './tag-vo';
 import { ArchiveVO } from './archive-vo';
 import { HasThumbnails } from './get-thumbnail';
+import { FileFormat, PermanentFile } from './file-vo';
 
 interface RecordVoOptions {
   dataStatus: DataStatus;
@@ -107,7 +109,7 @@ export class RecordVO
   // Other stuff
   public LocnVO: LocnVOData;
   public TimezoneVO: TimezoneVOData;
-  public FileVOs;
+  public FileVOs: PermanentFile[];
   public TagVOs: TagVOData[];
   public TextDataVOs;
   public ArchiveVOs: ArchiveVO[];
@@ -155,6 +157,17 @@ export class RecordVO
       this.ShareVOs = this.ShareVOs.map((data) => new ShareVO(data));
     }
   }
+
+  public getDownloadOptionsList() {
+    const files = [...(this.FileVOs ?? [])];
+    return prioritizeIf(
+      files,
+      (file) => file.format === FileFormat.Original,
+    ).map((file) => ({
+      name: file.type,
+      extension: file.type.split('.').pop(),
+    }));
+  }
 }
 
 export interface RecordVOData extends BaseVOData {

src/app/shared/components/audio/audio.component.ts

@@ -1,26 +1,18 @@
-import { Component, OnInit, Input, OnChanges } from '@angular/core';
+/* @format */
+import { Component, Input, OnChanges } from '@angular/core';
 import { RecordVO } from '@models';
-import { find } from 'lodash';
+import { GetAccessFile } from '@models/get-access-file';
 
 @Component({
   selector: 'pr-audio',
   templateUrl: './audio.component.html',
-  styleUrls: ['./audio.component.scss']
+  styleUrls: ['./audio.component.scss'],
 })
 export class AudioComponent implements OnChanges {
   @Input() item: RecordVO;
   audioSrc: string;
-  constructor() { }
 
   ngOnChanges(): void {
-    const convertedFile = find(this.item.FileVOs, {format: 'file.format.converted'}) as any;
-    const originalFile = find(this.item.FileVOs, {format: 'file.format.original'}) as any;
-
-    if (convertedFile) {
-      this.audioSrc = convertedFile.fileURL;
-    } else if (originalFile) {
-      this.audioSrc = originalFile.fileURL;
-    }
+    this.audioSrc = GetAccessFile(this.item)?.fileURL;
   }
-
 }