Add models from metadata-service

Author: jbuckner

src/models/file.ts

@@ -0,0 +1,112 @@
+import { Memoize } from 'typescript-memoize';
+import {
+  Byte,
+  ByteParser,
+  Duration,
+  DurationParser,
+  NumberParser,
+} from '@internetarchive/field-parsers';
+
+/**
+ * This represents an Internet Archive File
+ *
+ * @export
+ * @class File
+ */
+export class File {
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  readonly rawValue: Readonly<Record<string, any>>;
+
+  get name(): string {
+    return this.rawValue.name;
+  }
+
+  get source(): string {
+    return this.rawValue.source;
+  }
+
+  get btih(): string {
+    return this.rawValue.btih;
+  }
+
+  get md5(): string {
+    return this.rawValue.md5;
+  }
+
+  get format(): string {
+    return this.rawValue.format;
+  }
+
+  @Memoize() get mtime(): Date | undefined {
+    if (this.rawValue.mtime == null) {
+      return undefined;
+    }
+    const numberValue = NumberParser.shared.parseValue(this.rawValue.mtime);
+    if (numberValue) {
+      return new Date(numberValue * 1000);
+    }
+  }
+
+  get crc32(): string {
+    return this.rawValue.crc32;
+  }
+
+  get sha1(): string {
+    return this.rawValue.sha1;
+  }
+
+  get original(): string | undefined {
+    return this.rawValue.original;
+  }
+
+  @Memoize() get size(): Byte | undefined {
+    return this.rawValue.size != null
+      ? ByteParser.shared.parseValue(this.rawValue.size)
+      : undefined;
+  }
+
+  get title(): string | undefined {
+    return this.rawValue.title;
+  }
+
+  @Memoize() get length(): Duration | undefined {
+    return this.rawValue.length != null
+      ? DurationParser.shared.parseValue(this.rawValue.length)
+      : undefined;
+  }
+
+  @Memoize() get height(): number | undefined {
+    return this.rawValue.height != null
+      ? NumberParser.shared.parseValue(this.rawValue.height)
+      : undefined;
+  }
+
+  @Memoize() get width(): number | undefined {
+    return this.rawValue.width != null
+      ? NumberParser.shared.parseValue(this.rawValue.width)
+      : undefined;
+  }
+
+  @Memoize() get track(): number | undefined {
+    return this.rawValue.track != null
+      ? NumberParser.shared.parseValue(this.rawValue.track)
+      : undefined;
+  }
+
+  get external_identifier(): string | string[] | undefined {
+    return this.rawValue.external_identifier;
+  }
+
+  get creator(): string | undefined {
+    return this.rawValue.creator;
+  }
+
+  get album(): string | undefined {
+    return this.rawValue.album;
+  }
+
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  constructor(json: Record<string, any> = {}) {
+    this.rawValue = json;
+  }
+}

src/models/review.ts

@@ -0,0 +1,46 @@
+import { Memoize } from 'typescript-memoize';
+import { DateParser, NumberParser } from '@internetarchive/field-parsers';
+
+export class Review {
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  readonly rawValue: Readonly<Record<string, any>>;
+
+  get reviewbody(): string | undefined {
+    return this.rawValue.reviewbody;
+  }
+
+  get reviewtitle(): string | undefined {
+    return this.rawValue.reviewtitle;
+  }
+
+  get reviewer(): string | undefined {
+    return this.rawValue.reviewer;
+  }
+
+  get reviewer_itemname(): string | undefined {
+    return this.rawValue.reviewer_itemname;
+  }
+
+  @Memoize() get reviewdate(): Date | undefined {
+    return this.rawValue.reviewdate != null
+      ? DateParser.shared.parseValue(this.rawValue.reviewdate)
+      : undefined;
+  }
+
+  @Memoize() get createdate(): Date | undefined {
+    return this.rawValue.createdate != null
+      ? DateParser.shared.parseValue(this.rawValue.createdate)
+      : undefined;
+  }
+
+  @Memoize() get stars(): number | undefined {
+    return this.rawValue.stars != null
+      ? NumberParser.shared.parseValue(this.rawValue.stars)
+      : undefined;
+  }
+
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  constructor(json: Record<string, any> = {}) {
+    this.rawValue = json;
+  }
+}

src/models/speech-music-asr-entry.ts

@@ -0,0 +1,10 @@
+/**
+ * This is the format used for radio transcripts
+ */
+export type SpeechMusicASREntry = {
+  readonly end: number;
+  readonly id: number;
+  readonly is_music: boolean;
+  readonly start: number;
+  readonly text: string;
+};

src/models/task.ts

@@ -0,0 +1,13 @@
+export type TaskColor = 'red' | 'green' | 'blue' | 'purple' | 'brown';
+
+export type TaskStatus = 'error' | 'queued' | 'running' | 'passed' | 'paused';
+
+export type Task = {
+  task_id: number;
+  cmd: string;
+  priority: number;
+  wait_admin: number;
+  args: Record<string, string>;
+  color: TaskColor;
+  status: TaskStatus;
+};

test/models/file.test.ts

@@ -0,0 +1,62 @@
+import { expect } from '@open-wc/testing';
+
+import { File } from '../../src/models/file';
+
+describe('File', () => {
+  it('can be instantiated with an object', async () => {
+    const file = new File({ name: 'foo.jpg' });
+    expect(file.name).to.equal('foo.jpg');
+  });
+
+  // some fields like size and length get converted to their proper types
+  it('properly instantiates modeled fields', async () => {
+    const file = new File({
+      name: 'foo.jpg',
+      size: '1234',
+      length: '1:23',
+      height: '1080',
+      width: '1920',
+      track: '1',
+    });
+    expect(file.size).to.equal(1234);
+    expect(file.length).to.equal(83);
+    expect(file.height).to.equal(1080);
+    expect(file.width).to.equal(1920);
+    expect(file.track).to.equal(1);
+  });
+
+  it('external_identifier can be a single value', async () => {
+    const file = new File({ name: 'foo.jpg', external_identifier: 'bar' });
+    expect(file.external_identifier).to.equal('bar');
+  });
+
+  it('external_identifier can be an array', async () => {
+    const file = new File({
+      name: 'foo.jpg',
+      external_identifier: ['foo', 'bar'],
+    });
+    expect(file.external_identifier).to.deep.equal(['foo', 'bar']);
+  });
+
+  it('handles falsy values properly', async () => {
+    const file = new File({
+      name: 'foo.jpg',
+      size: 0,
+      track: 0,
+    });
+    expect(file.size).to.not.be.undefined;
+    expect(file.size).to.equal(0);
+    expect(file.track).to.not.be.undefined;
+    expect(file.track).to.equal(0);
+  });
+
+  it('parses mtime properly', async () => {
+    const file = new File({
+      name: 'foo.jpg',
+      mtime: '1639591034',
+    });
+    expect(file.mtime).to.not.be.undefined;
+    expect(file.mtime instanceof Date).to.be.true;
+    expect(file.mtime?.getTime()).to.equal(1639591034000);
+  });
+});

test/models/review.test.ts

@@ -0,0 +1,59 @@
+import { expect } from '@open-wc/testing';
+
+import { Review } from '../../src/models/review';
+
+describe('Review', () => {
+  it('can be instantiated with a title', async () => {
+    const review = new Review({
+      reviewtitle: 'It was awesome!',
+    });
+    expect(review.reviewtitle).to.equal('It was awesome!');
+  });
+
+  it('stars get converted to a number', async () => {
+    const review = new Review({
+      stars: '5',
+    });
+    expect(review.stars).to.equal(5);
+  });
+
+  it('reviewdate get converted to a date', async () => {
+    const review = new Review({
+      reviewdate: '2014-05-09 09:47:15',
+    });
+
+    const expected = new Date();
+    expected.setHours(9);
+    expected.setMinutes(47);
+    expected.setSeconds(15);
+    expected.setMilliseconds(0);
+    expected.setMonth(4);
+    expected.setDate(9);
+    expected.setFullYear(2014);
+
+    expect(review.reviewdate?.getTime()).to.equal(expected.getTime());
+  });
+
+  it('handles falsy values properly', async () => {
+    const review = new Review({
+      reviewtitle: 'yay',
+      reviewdate: '0',
+      stars: 0,
+    });
+
+    const expected = new Date();
+    expected.setHours(0);
+    expected.setMinutes(0);
+    expected.setSeconds(0);
+    expected.setMilliseconds(0);
+    expected.setMonth(0);
+    expected.setDate(1);
+    expected.setFullYear(2000);
+
+    expect(review.reviewtitle).to.equal('yay');
+    expect(review.reviewdate).to.not.be.undefined;
+    expect(review.reviewdate?.getTime()).to.equal(expected.getTime());
+    expect(review.stars).to.not.be.undefined;
+    expect(review.stars).to.equal(0);
+  });
+});