fontastic 0.1.3

package/src/app/core/services/database/database.service.ts

@@ -0,0 +1,286 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { FontService } from '@app/core/services/font/font.service';
+import { MessageService } from '@app/core/services/message/message.service';
+import { PresentationService } from '@app/core/services/presentation/presentation.service';
+import { ElectronService } from '@app/core/services/electron/electron.service';
+import { Store } from '@main/database/entity/Store.schema';
+import { Collection } from '@main/database/entity/Collection.schema';
+import { QueryOptions, SystemStats } from '@main/types';
+import { StorageType } from '@main/enums';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DatabaseService {
+
+  _activePage = new BehaviorSubject<number>(1);
+  watchActivePage$ = this._activePage.asObservable();
+
+  // STORE
+  _storeId = new BehaviorSubject<number>(0);
+  watchStoreId$ = this._storeId.asObservable();
+
+  _storeResult = new BehaviorSubject<Store>(null);
+  watchStoreResult$ = this._storeResult.asObservable();
+
+  _storeResultSet = new BehaviorSubject<Store[]>([]);
+  watchStoreResultSet$ = this._storeResultSet.asObservable();
+
+  // COLLECTION 
+  _collectionId = new BehaviorSubject<number>(0);
+  watchCollectionId$ = this._collectionId.asObservable();
+
+  _collectionResult = new BehaviorSubject<Collection>(null);
+  watchCollectionResult$ = this._collectionResult.asObservable();
+
+  _collectionResultSet = new BehaviorSubject<Collection[]>([]);
+  watchCollectionResultSet$ = this._collectionResultSet.asObservable();
+
+  // COUNTS 
+  _resultSetCount = new BehaviorSubject<number>(0);
+  watchResultSetCount$ = this._resultSetCount.asObservable();
+
+  _resultSetTotal = new BehaviorSubject<number>(0);
+  watchResultSetTotal$ = this._resultSetTotal.asObservable();
+
+  _queryOptions = new BehaviorSubject<QueryOptions>({
+    order: {
+      column: 'id',
+      direction: 'ASC',
+    },
+    where: [],
+    skip: 0,
+    take: 100,
+    run: false
+  });
+  watchQueryOptions$ = this._queryOptions.asObservable();
+
+  order = { column: 'file_name', direction: 'ASC' };
+  where = [];
+  skip = 0;
+  take = 100;
+
+  search = false;
+  stats = false;
+
+  _systemStats = new BehaviorSubject<SystemStats>({
+    rowCount: 0,
+    favoriteCount: 0,
+    systemCount: 0,
+    activatedCount: 0,
+    temporaryCount: 0
+  });
+  watchSystemStats$ = this._systemStats.asObservable();
+
+  constructor(
+    public fontService: FontService,
+    public messageService: MessageService,
+    public presentationService: PresentationService,
+    public electronService: ElectronService
+  ) {
+
+    if (electronService.isElectron) {
+
+      if (this.electronService.store.has(StorageType.CollectionId)) {
+        const id = this.electronService.store.get(StorageType.CollectionId);
+        if (id) {
+          this.setCollectionId(id);
+        }
+      }
+
+      if (this.electronService.store.has(StorageType.StoreId)) {
+        const id = this.electronService.store.get(StorageType.StoreId);
+        if (id) {
+          this.setStoreId(id);
+        }
+      }
+
+      this.watchQueryOptions$.subscribe((options: QueryOptions) => {
+        if (options.run) {
+          this.execute(options);
+        }
+      });
+
+      this.watchStoreId$.subscribe((id: number) => {
+        if (Number.isInteger(id)) {
+          messageService.storeFindOne({ where: { id } }).then((result: Store) => {
+            if (result) {
+              this.setStoreResult(result);
+              const resource = this.fontService.withTransferProtocol(result.file_path, 'file');
+              this.fontService.load(resource).then((font: opentype.Font) => this.fontService.setFontObject(font));
+            }
+          });
+        }
+      });
+
+      // System boot
+      this.fetchCollections();
+
+      this.fetchSystemStats();
+    }
+  }
+
+  fetchCollections() {
+    this.messageService.collectionFetch({}).then((result: Collection[]) => this.setCollectionResultSet(result));
+  }
+
+  getResultSetCount(): number {
+    return this._resultSetCount.getValue();
+  }
+
+  getResultSetTotal(): number {
+    return this._resultSetTotal.getValue();
+  }
+
+  /**
+   * BEGIN STORE 
+   */
+
+  setStoreId(id: number): void {
+    this._storeId.next(id);
+    this.electronService.store.set(StorageType.StoreId, id);
+  }
+
+  getStoreId(): number {
+    return this._storeId.getValue();
+  }
+
+  setStoreResult(result: Store) {
+    this._storeResult.next(result);
+  }
+
+  getStoreResult(): Store {
+    return this._storeResult.getValue();
+  }
+
+  setStoreResultSet(results: Store[]): void {
+    this._storeResultSet.next(results);
+  }
+
+  getStoreResultSet(): Store[] {
+    return this._storeResultSet.getValue();
+  }
+
+  /**
+   * BEGIN SYSTEM STATS  
+   */
+
+  setSystemStats(results: SystemStats): void {
+    this._systemStats.next(results);
+  }
+
+  getSystemStats(): SystemStats {
+    return this._systemStats.getValue();
+  }
+
+  fetchSystemStats(): void {
+    this.messageService.fetchSystemStats().then((result: SystemStats) => this.setSystemStats(result));
+  }
+
+  /**
+   * BEGIN COLLECTION 
+   */
+
+  setCollectionId(id: number): void {
+    this._collectionId.next(id);
+    this.electronService.store.set(StorageType.CollectionId, id);
+  }
+
+  getCollectionId(): number {
+    return this._collectionId.getValue();
+  }
+
+  setCollectionResult(result: Collection) {
+    this._collectionResult.next(result);
+  }
+
+  getCollectionResult(): Collection {
+    return this._collectionResult.getValue();
+  }
+
+  setCollectionResultSet(results: Collection[]) {
+    this._collectionResultSet.next(results);
+  }
+
+  getCollectionResultSet(): Collection[] {
+    return this._collectionResultSet.getValue();
+  }
+
+  /**
+   * BEGIN QUERY OPTIONS
+   */
+
+  setQueryOptions(options: any): DatabaseService {
+    this._queryOptions.next(options);
+    return this;
+  }
+
+  getQueryOptions(): QueryOptions {
+    return this._queryOptions.getValue();
+  }
+
+  setOrder(column: string, direction: string): DatabaseService {
+    this.order = { column, direction };
+    return this;
+  }
+
+  setWhere(key: string, value: any): DatabaseService {
+    this.where.push({ key, value });
+    return this;
+  }
+
+  setSkip(skip: number): DatabaseService {
+    this.skip = skip;
+    return this;
+  }
+
+  setTake(take: number): DatabaseService {
+    this.take = take;
+    return this;
+  }
+
+  setSearch(search: boolean): DatabaseService {
+    this.search = search;
+    return this;
+  }
+
+  run(): void {
+    this.setQueryOptions({
+      order: this.order,
+      where: this.where,
+      skip: this.skip,
+      take: this.take,
+      run: true
+    }).resetWhere();
+  }
+
+  resetWhere(): DatabaseService {
+    this.where = [];
+    return this;
+  }
+
+  resetPage(page: number): DatabaseService {
+    this._activePage.next(page);
+    return this;
+  }
+
+  async execute(options: QueryOptions) {
+    const t0 = performance.now();
+    const [results, total]: any = (this.search) ? await this.fetchSearch(options) : await this.fetchStore(options);
+    const t1 = performance.now();
+    this._resultSetCount.next(results.length);
+    this._resultSetTotal.next(total);
+    this._storeResultSet.next(results);
+    this.presentationService.setSystemLoading(false);
+    console.warn(t1 - t0, 'milliseconds');
+  }
+
+  async fetchStore(options: QueryOptions) {
+    return await this.messageService.storeFetch((this.getCollectionId() && this.stats === false) ? { ...options, collectionId: this.getCollectionId() } : options);
+  }
+
+  async fetchSearch(options: QueryOptions) {
+    return await this.messageService.storeSearch(options);
+  }
+}

package/src/app/core/services/electron/electron.service.spec.ts

@@ -0,0 +1,12 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ElectronService } from './electron.service';
+
+describe('ElectronService', () => {
+  beforeEach(() => TestBed.configureTestingModule({}));
+
+  it('should be created', () => {
+    const service: ElectronService = TestBed.inject(ElectronService);
+    expect(service).toBeTruthy();
+  });
+});

package/src/app/core/services/electron/electron.service.ts

@@ -0,0 +1,62 @@
+import { Injectable } from '@angular/core';
+
+// If you import a module but never use any of the imported values other than as TypeScript types,
+// the resulting javascript file will look as if you never imported the module at all.
+import { ipcRenderer, webFrame } from 'electron';
+import * as childProcess from 'child_process';
+import * as fs from 'fs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ElectronService {
+  ipcRenderer: typeof ipcRenderer;
+  webFrame: typeof webFrame;
+  childProcess: typeof childProcess;
+  fs: typeof fs;
+  store: any;
+
+  constructor() {
+    if (this.isElectron) {
+      this.ipcRenderer = window.require('electron').ipcRenderer;
+      this.webFrame = window.require('electron').webFrame;
+
+      this.ipcRenderer.setMaxListeners(0);
+
+      this.fs = window.require('fs');
+
+      /* eslint-disable-next-line @typescript-eslint/naming-convention */
+      const Store = window.require('electron-store');
+      this.store = new Store();
+
+      // this.childProcess = window.require('child_process');
+      // this.childProcess.exec('node -v', (error, stdout, stderr) => {
+      //   if (error) {
+      //     console.error(`error: ${error.message}`);
+      //     return;
+      //   }
+      //   if (stderr) {
+      //     console.error(`stderr: ${stderr}`);
+      //     return;
+      //   }
+      //   console.log(`stdout:\n${stdout}`);
+      // });
+
+      // Notes :
+      // * A NodeJS's dependency imported with 'window.require' MUST BE present in `dependencies` of both `app/package.json`
+      // and `package.json (root folder)` in order to make it work here in Electron's Renderer process (src folder)
+      // because it will loaded at runtime by Electron.
+      // * A NodeJS's dependency imported with TS module import (ex: import { Dropbox } from 'dropbox') CAN only be present
+      // in `dependencies` of `package.json (root folder)` because it is loaded during build phase and does not need to be
+      // in the final bundle. Reminder : only if not used in Electron's Main process (app folder)
+
+      // If you want to use a NodeJS 3rd party deps in Renderer process,
+      // ipcRenderer.invoke can serve many common use cases.
+      // https://www.electronjs.org/docs/latest/api/ipc-renderer#ipcrendererinvokechannel-args
+    }
+  }
+
+  get isElectron(): boolean {
+    return !!(window && window.process && window.process.type);
+  }
+}

package/src/app/core/services/font/font.service.ts

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import { UtilsService } from '@app/core/services/utils/utils.service';
+import * as opentype from 'opentype.js';
+import { BehaviorSubject } from 'rxjs';
+import { fontTableData } from '@main/config/system';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class FontService {
+
+  _fontObject = new BehaviorSubject<opentype.Font>(undefined);
+  watchFontObject$ = this._fontObject.asObservable();
+
+  fontTableData = fontTableData;
+
+  constructor(
+    private utils: UtilsService
+  ) { }
+
+  async load(filePath: string): Promise<opentype.Font> {
+    return opentype.load(filePath);
+  }
+
+  setFontObject(font: opentype.Font): void {
+    this._fontObject.next(font);
+  }
+
+  getFontObject(): opentype.Font {
+    return this._fontObject.getValue();
+  }
+
+  withTransferProtocol(resource: string, protocol: string = 'file') {
+    return `${protocol}://${resource}`;
+  }
+
+  clearCanvas(context: CanvasRenderingContext2D) {
+    context.clearRect(0, 0, context.canvas.width, context.canvas.height);
+    context.beginPath();
+  }
+
+  normalizeTable(table: any) {
+    if (table) {
+      return Object.keys(table).map((property) => {
+        const name = this.utils.capitalize(this.utils.normalizeCamelCase(property));
+        const prop = table[property];
+
+        let value: any;
+        if (Array.isArray(prop) && typeof prop[0] === 'object') {
+          value = prop.map((v: any) => JSON.stringify(v));
+        } else if (typeof prop === 'object') {
+          value = JSON.stringify(prop);
+        } else {
+          value = prop;
+        }
+
+        return {
+          name,
+          value
+        };
+      });
+    }
+  }
+
+  normalizeNameTable(table: any) {
+    if (table) {
+      return Object.keys(table).map((property) => {
+        const lang = Object.keys(table[property])[0];
+        const name = this.utils.escapeHtml(this.utils.capitalize(this.utils.normalizeCamelCase(property)));
+        const value = this.utils.escapeHtml(table[property][lang]);
+        return {
+          name,
+          lang,
+          value
+        };
+      });
+    }
+  }
+}

package/src/app/core/services/gravatar/gravatar.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { GravatarService } from './gravatar.service';
+
+describe('GravatarService', () => {
+  let service: GravatarService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(GravatarService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/app/core/services/gravatar/gravatar.service.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { Md5 } from 'ts-md5';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class GravatarService {
+
+  public gravatarSize = 16;
+  public gravatarFallback = 'mm';
+
+  constructor() { }
+
+  url(email: string, size: number = this.gravatarSize, fallback: string = this.gravatarFallback): string {
+    const emailHash = Md5.hashStr(email.trim().toLowerCase());
+    return `https://www.gravatar.com/avatar/${emailHash}?s=${size}&d=${fallback}`;
+  }
+}

package/src/app/core/services/index.ts

@@ -0,0 +1,14 @@
+export * from './utils/utils.service';
+export * from './electron/electron.service';
+export * from './message/message.service';
+export * from './breadcrumb/breadcrumb.service';
+export * from './database/database.service';
+export * from './presentation/presentation.service';
+export * from './gravatar/gravatar.service';
+export * from './config/config.service';
+export * from './alert/alert.service';
+export * from './auth/auth.service';
+export * from './font/font.service';
+export * from './news/news.service';
+export * from './modal/modal.service';
+export * from './boot/boot.service';