@shaxpir/duiduidui-models 1.0.0

package/lib/models/content/Device.ts

@@ -0,0 +1,86 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync, ShareSyncFactory } from '../../repo/ShareSync';
+import { CachingHasher } from '../../util/CachingHasher';
+import { BatchOperation } from '../markup/Operation';
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { ContentKind } from './ContentKind';
+import { CompactDateTime, MultiClock } from './Time';
+
+export interface LastSync {
+  at_utc_time:CompactDateTime;
+}
+
+export interface DevicePayload {
+  last_sync?:LastSync;
+}
+
+export interface DeviceBody extends ContentBody {
+  meta:ContentMeta;
+  payload:DevicePayload;
+}
+
+export class Device extends Content {
+
+  public static makeProfleId(userId:ContentId):ContentId {
+    return CachingHasher.makeMd5ContentId(userId + "-" + ContentKind.PROFILE);
+  }
+
+  public static create(
+    userId:ContentId,
+    deviceId:ContentId,
+    theme:string,
+    typeface:string,
+    typesize:string
+  ):Device {
+    const now = MultiClock.now();
+    return ShareSyncFactory.get().createContent(
+      {
+        meta : {
+          ref : deviceId,
+          is_head : true,
+          kind : ContentKind.DEVICE,
+          id : deviceId,
+          owner : userId,
+          created_at : now,
+          updated_at : now
+        },
+        payload : {
+          last_sync : { at_utc_time : null as CompactDateTime }
+        }
+      }
+    ) as Device;
+  }
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+  }
+
+  public get payload():DevicePayload {
+    this.checkDisposed("Device.payload");
+    return this.doc.data.payload as DevicePayload;
+  }
+
+  public get lastSyncAtUtcTime():CompactDateTime {
+    this.checkDisposed("Device.lastSyncAtUtcTime");
+    this.ensureLastSyncAtUtcTimeExists();
+    return this.payload.last_sync.at_utc_time;
+  }
+  public setLastSyncAtUtcTime(value:CompactDateTime):void {
+    this.checkDisposed("Device.setLastSyncAtUtcTime");
+    this.ensureLastSyncAtUtcTimeExists();
+    if (this.lastSyncAtUtcTime !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'last_sync', 'at_utc_time' ] , value);
+      batch.commit();
+    }
+  }
+  private ensureLastSyncAtUtcTimeExists():void {
+    this.checkDisposed("Device.ensureLastSyncAtUtcTimeExists");
+    // If the 'last_sync' field doesn't exist, add it first...
+    if (!this.payload.hasOwnProperty('last_sync')) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'last_sync' ] , { at_utc_time : null as CompactDateTime });
+      batch.commit();
+    }
+  }
+}

package/lib/models/content/DictionaryEntry.ts

@@ -0,0 +1,22 @@
+export interface DictionaryEntry {
+  text:string;
+  rank:number;
+  learn_rank:number;
+  is_starred?:boolean;
+  tags:string[];
+}
+
+export interface Pronouncable {
+  pinyin:string; // hanzi, phrase
+  pinyin_tokenized?:string; // phrase
+  pinyin_normalized:string; // hanzi, phrase
+}
+
+export interface Definable {
+  definition:string; // hanzi, phrase
+  definition_analysis:string; // hanzi, phrase
+  translation?:string; // hanzi
+  transliteration?:string; // phrase
+  function?:string; // hanzi
+  usage?:string; // phrase
+}

package/lib/models/content/GeoLocation.ts

@@ -0,0 +1,4 @@
+export interface GeoLocation {
+  lat:number;
+  lon:number;
+}

package/lib/models/content/Hanzi.ts

@@ -0,0 +1,25 @@
+import { ContentBody, ContentMeta } from "./Content";
+import { Definable, DictionaryEntry, Pronouncable } from "./DictionaryEntry";
+
+export interface HanziComponent {
+  component:string;
+  meaning:string;
+  pinyin:string;
+}
+
+export interface HanziSense extends Definable, Pronouncable {
+  phrases:string[];
+}
+
+export interface HanziPayload extends DictionaryEntry {
+  components:HanziComponent[];
+  component_analysis:string;
+  radical:string;
+  radical_analysis:string;
+  senses:HanziSense[];
+}
+
+export interface HanziBody extends ContentBody {
+  meta:ContentMeta;
+  payload:HanziPayload;
+}

package/lib/models/content/Manifest.ts

@@ -0,0 +1,162 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync, ShareSyncFactory } from '../../repo/ShareSync';
+import { CachingHasher } from '../../util/CachingHasher';
+import { BatchOperation } from "../markup/Operation";
+import { Content, ContentId, ContentRef } from "./Content";
+import { ContentKind } from './ContentKind';
+import { Model } from './Model';
+import { CompactDateTime, SingleTime, Time } from './Time';
+
+export interface ManifestMeta {
+  kind:ContentKind;
+  ref:ContentRef;
+  updated_at:SingleTime;
+  owner:ContentId;
+}
+
+export interface ManifestBody {
+  meta:ManifestMeta;
+  payload:ManifestPayload;
+}
+
+export interface ManifestEntry {
+  kind:ContentKind;
+  ref:ContentRef;
+  at_utc_time:CompactDateTime;
+}
+
+export interface ManifestPayload {
+  device:any;
+  media:any;
+  profile:any;
+  user:any;
+}
+
+export class Manifest extends Model {
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+  }
+
+  public static makeManifestId(userId:ContentId):ContentId {
+    return CachingHasher.makeMd5ContentId(userId + "-" + ContentKind.MANIFEST);
+  }
+
+  public static create(userId:ContentId):Manifest {
+    const now:CompactDateTime = Time.utc();
+    const manifestId = Manifest.makeManifestId(userId);
+    return ShareSyncFactory.get().createManifest({
+      meta : {
+        kind : ContentKind.MANIFEST,
+        ref : manifestId,
+        updated_at : {
+          utc_time : now
+        },
+        owner : userId
+      },
+      payload: {
+        device : {},
+        media : {},
+        profile : {},
+        user: {}
+      }
+    });
+  }
+
+  public get meta():ManifestMeta {
+    this.checkDisposed("Manifest.meta");
+    return this.doc.data.meta as ManifestMeta;
+  }
+
+  public get owner():ContentId {
+    this.checkDisposed("Manifest.userId");
+    return this.doc.data.meta.owner as ContentId;
+  }
+
+  public canUserView(userId:ContentId):boolean {
+    this.checkDisposed("Manifest.canUserView");
+    return this.doc.data.meta.owner === userId;
+  }
+
+  public doesContentExist(kind:ContentKind, ref:ContentRef):boolean {
+    this.checkDisposed("Manifest.doesContentExist");
+    return this.doc.data &&
+      this.doc.data.payload &&
+      this.doc.data.payload[kind] &&
+      this.doc.data.payload[kind][ref];
+  }
+
+  public getUtcTimeOf(kind:ContentKind, ref:ContentRef):CompactDateTime {
+    this.checkDisposed("Manifest.getTimestampOf");
+    if (this.doesContentExist(kind, ref)) {
+      return this.doc.data.payload[kind][ref] as CompactDateTime;
+    }
+    return null as CompactDateTime;
+  }
+
+  public getAllEntries():ManifestEntry[] {
+    return this.getAllEntriesWhere(() => true);
+  }
+
+  public getAllEntriesWhere(
+    predicate?:(entry:ManifestEntry) => boolean
+  ):ManifestEntry[] {
+    const entries = [] as ManifestEntry[];
+    if (this.exists() && this.doc.data.payload) {
+      Manifest.forEachEntry(
+        this.doc.data as ManifestBody,
+        (entry:ManifestEntry) => {
+          if (!predicate || predicate(entry)) {
+            entries.push(entry);
+          }
+        }
+      );
+    }
+    return entries;
+  }
+
+  public update(content:Content):void {
+    this.checkDisposed("Manifest.update");
+    content.acquire().then(() => {
+
+      const kind:ContentKind = content.kind;
+      const contentRef:ContentId = content.ref;
+
+      const timestamp:CompactDateTime = content.updatedAt.utc_time;
+      const batch = new BatchOperation(this, content.meta.updated_at);
+
+      // Update the embedded timestamp of this content item
+      batch.setPathValue([ 'payload', kind, contentRef ], timestamp);
+
+      batch.commit();
+      content.release();
+    });
+  }
+
+  public static forEachEntry(
+    body:ManifestBody,
+    callback:(entry:ManifestEntry) => void
+  ):void {
+    const kinds = Object.keys(body.payload);
+    for (let i = 0; i < kinds.length; i++) {
+      const kind = kinds[i] as ContentKind;
+      const manifestPayload = (body.payload as any)[kind];
+      const refs = Object.keys(manifestPayload);
+      for (let j = 0; j < refs.length; j++) {
+        const ref = refs[j] as ContentRef;
+        const timestamp = manifestPayload[ref] as CompactDateTime;
+        if (ref && timestamp) {
+          const entry = {
+            kind : kind,
+            ref : ref,
+            at_utc_time : timestamp
+          };
+          callback(entry);
+        } else {
+          console.error(`manifest with missing ref or timestamp: ${JSON.stringify(body)}`);
+        }
+      }
+    }
+  }
+
+}

package/lib/models/content/Media.ts

@@ -0,0 +1,126 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync, ShareSyncFactory } from '../../repo/ShareSync';
+import { Content, ContentBody, ContentId, ContentMeta } from './Content';
+import { ContentKind } from './ContentKind';
+import { MultiClock } from './Time';
+
+export interface MediaDimensions {
+  width:number;
+  height:number;
+}
+
+export interface MediaCropping extends MediaDimensions {
+  offset_top:number;
+  offset_left:number;
+}
+
+export interface MediaPayload extends MediaDimensions {
+  extension:string;
+  bytes:number;
+}
+
+export interface MediaBody extends ContentBody {
+  meta:ContentMeta;
+  payload:MediaPayload;
+}
+
+export class Media extends Content {
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+  }
+
+  public get payload():MediaPayload {
+    this.checkDisposed("Media.payload");
+    return this.doc.data.payload as MediaPayload;
+  }
+
+  public static create(
+    userId:ContentId,
+    mediaId:ContentId,
+    payload:MediaPayload
+  ):Media {
+    const now = MultiClock.now();
+    return ShareSyncFactory.get().createContent({
+      meta : {
+        ref : mediaId,
+        is_head : true,
+        kind : ContentKind.MEDIA,
+        id : mediaId,
+        owner : userId,
+        created_at : now,
+        updated_at : now
+      },
+      payload : payload
+    }) as Media;
+  }
+
+  get bytes():number {
+    this.checkDisposed("Media.bytes");
+    return this.payload.bytes;
+  }
+
+  get width():number {
+    this.checkDisposed("Media.width");
+    return this.payload.width;
+  }
+
+  get height():number {
+    this.checkDisposed("Media.height");
+    return this.payload.height;
+  }
+
+  get extension():string {
+    this.checkDisposed("Media.extension");
+    return this.payload.extension;
+  }
+
+  public get mediaType():string {
+    this.checkDisposed("Media.mediaType");
+    const extension:string = this.extension;
+    if (extension === "jpg" || extension === "jpeg") {
+      return "image/jpeg";
+    } else if (extension === "png") {
+      return "image/png";
+    } else if (extension === "gif") {
+      return "image/gif";
+    } else if (extension === "svg") {
+      return "image/svg+xml";
+    } else if (extension === "bmp") {
+      return "image/bmp";
+    }
+    return "image/" + extension;
+  }
+
+  public scaleToFit(boxSize:number, cropping:MediaCropping):MediaCropping {
+    this.checkDisposed("Media.scaleToFit");
+    const zoom = boxSize / cropping.width;
+    const scaledWidth = Math.floor(this.width * zoom);
+    const scaledHeight = Math.floor(this.height * zoom);
+    const offsetLeft = -Math.floor(cropping.offset_left * zoom);
+    const offsetTop = -Math.floor(cropping.offset_top * zoom);
+    return {
+      "offset_top" : offsetTop,
+      "offset_left" : offsetLeft,
+      "width" : scaledWidth,
+      "height" : scaledHeight
+    };
+  }
+
+  public static makeDefaultCropping(media:Media):MediaCropping {
+    const width = media.width;
+    const height = media.height;
+    const isLandscapeOrSquare:boolean = width >= height;
+    const isPortraitOrSquare:boolean = height >= width;
+    const croppingOffsetTop:number = isLandscapeOrSquare ? 0 : Math.floor((height - width) / 2);
+    const croppingOffsetLeft:number = isPortraitOrSquare ? 0 : Math.floor((width - height) / 2);
+    const croppingWidth:number = isLandscapeOrSquare ? height : width;
+    const croppingHeight:number = isPortraitOrSquare ? width : height;
+    return {
+      offset_top : croppingOffsetTop,
+      offset_left : croppingOffsetLeft,
+      width : croppingWidth,
+      height : croppingHeight
+    };
+  }
+}