fontastic 0.1.3

package/app/core/ConfigManager.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_1 = require("../config/database");
+const StorageType_1 = require("../enums/StorageType");
+const Store = require('electron-store');
+const store = new Store();
+class ConfigManager {
+    constructor(systemManager) {
+        this.systemManager = systemManager;
+    }
+    set(key, value) {
+        store.set(key, value);
+    }
+    get(key = null) {
+        if (key) {
+            return store.get(key);
+        }
+        return store.store;
+    }
+    has(key) {
+        return store.has(key);
+    }
+    delete(key) {
+        return store.delete(key);
+    }
+    clear() {
+        return store.clear();
+    }
+    toArray() {
+        return store.store;
+    }
+    initialize() {
+        this.initDatabaseConfig();
+        this.initSettingsConfig();
+    }
+    initSettingsConfig() {
+        const settings = {
+            import: {
+                type: 'ask'
+            }
+        };
+        if (this.has(StorageType_1.StorageType.Options)) {
+            const saved = this.get(StorageType_1.StorageType.Options);
+            this.set(StorageType_1.StorageType.Options, Object.assign(Object.assign({}, settings), saved));
+        }
+        else {
+            this.set(StorageType_1.StorageType.Options, settings);
+        }
+    }
+    initDatabaseConfig() {
+        let store = this.get(StorageType_1.StorageType.Database);
+        // @TODO Remove MySQL connection if not in production.
+        // Problematic when switching between production and development. Problem arises when connection is not enabled.
+        // database.connections = this.systemManager.isProduction() ? database.connections.filter((item: any) => item.name === 'default') : database.connections;
+        // Assign user data path to default database.
+        database_1.database.connections = database_1.database.connections.filter((item) => {
+            if (item.name === 'default' && item.type === 'sqlite') {
+                item.database = this.systemManager.getDatabasePath(item.database);
+            }
+            return item;
+        });
+        if (!store) {
+            this.set(StorageType_1.StorageType.Database, database_1.database);
+        }
+        else {
+            // Resets database.
+            //this.set(StorageType.Database, database);
+        }
+    }
+    createDbConnection(options) {
+        if (options.name === 'default') {
+            return;
+        }
+        let connections = this.get(StorageType_1.StorageType.Database).connections;
+        const found = connections.find((item) => item.name === options.name);
+        if (found) {
+            for (const i in connections) {
+                if (connections[i].name == options.name) {
+                    connections[i] = options;
+                }
+            }
+            this.set(StorageType_1.StorageType.DatabaseConnections, connections);
+        }
+        else {
+            this.set(StorageType_1.StorageType.DatabaseConnections, connections.push(options));
+        }
+    }
+    enableDbConnection(options) {
+        let config = this.get(StorageType_1.StorageType.Database);
+        config.connections = config.connections.filter((item) => {
+            item.enabled = (item.name === options.name) ? true : false;
+            return item;
+        });
+        this.set(StorageType_1.StorageType.Database, config);
+        return config;
+    }
+    deleteDbConnection(options) {
+        if (options.name === 'default') {
+            return;
+        }
+        let connections = this.get(StorageType_1.StorageType.Database).connections;
+        const found = connections.find((item) => item.name === options.name);
+        if (found) {
+            for (const i in connections) {
+                if (connections[i].name == options.name) {
+                    connections.splice(i, 1);
+                }
+            }
+            this.set(StorageType_1.StorageType.DatabaseConnections, connections);
+        }
+    }
+}
+exports.default = ConfigManager;
+//# sourceMappingURL=ConfigManager.js.map

package/app/core/ConfigManager.ts

@@ -0,0 +1,137 @@
+import SystemManager from './SystemManager';
+import { database } from '../config/database';
+import { StorageType } from '../enums/StorageType';
+
+const Store = require('electron-store');
+const store = new Store();
+
+export default class ConfigManager {
+
+  systemManager: SystemManager;
+
+  constructor(systemManager: SystemManager) {
+    this.systemManager = systemManager;
+  }
+
+  set(key: string, value: any): void {
+    store.set(key, value);
+  }
+
+  get(key: string = null): any {
+    if (key) {
+      return store.get(key);
+    }
+    return store.store;
+  }
+
+  has(key: string): boolean {
+    return store.has(key);
+  }
+
+  delete(key: string): any {
+    return store.delete(key);
+  }
+
+  clear(): any {
+    return store.clear();
+  }
+
+  toArray(): any {
+    return store.store;
+  }
+
+  initialize(): void {
+    this.initDatabaseConfig();
+    this.initSettingsConfig();
+  }
+
+  initSettingsConfig(): void {
+    const settings = {
+      import: {
+        type: 'ask'
+      }
+    };
+    if (this.has(StorageType.Options)) {
+      const saved = this.get(StorageType.Options);
+      this.set(StorageType.Options, { ...settings, ...saved });
+    } else {
+      this.set(StorageType.Options, settings);
+    }
+  }
+
+  initDatabaseConfig(): void {
+    let store = this.get(StorageType.Database);
+
+    // @TODO Remove MySQL connection if not in production.
+    // Problematic when switching between production and development. Problem arises when connection is not enabled.
+    // database.connections = this.systemManager.isProduction() ? database.connections.filter((item: any) => item.name === 'default') : database.connections;
+
+    // Assign user data path to default database.
+    database.connections = database.connections.filter((item: any) => {
+      if (item.name === 'default' && item.type === 'sqlite') {
+        item.database = this.systemManager.getDatabasePath(item.database);
+      }
+      return item;
+    })
+
+    if (!store) {
+      this.set(StorageType.Database, database);
+    } else {
+      // Resets database.
+      //this.set(StorageType.Database, database);
+    }
+  }
+
+  createDbConnection(options: any): void {
+    if (options.name === 'default') {
+      return;
+    }
+
+    let connections = this.get(StorageType.Database).connections;
+
+    const found = connections.find((item: any) => item.name === options.name);
+
+    if (found) {
+      for (const i in connections) {
+        if (connections[i].name == options.name) {
+          connections[i] = options;
+        }
+      }
+      this.set(StorageType.DatabaseConnections, connections);
+    } else {
+      this.set(StorageType.DatabaseConnections, connections.push(options));
+    }
+  }
+
+  enableDbConnection(options: any): void {
+    let config = this.get(StorageType.Database);
+
+    config.connections = config.connections.filter((item: any) => {
+      item.enabled = (item.name === options.name) ? true : false;
+      return item;
+    })
+
+    this.set(StorageType.Database, config);
+
+    return config;
+  }
+
+  deleteDbConnection(options: any): void {
+    if (options.name === 'default') {
+      return;
+    }
+
+    let connections = this.get(StorageType.Database).connections;
+
+    const found = connections.find((item: any) => item.name === options.name);
+
+    if (found) {
+      for (const i in connections) {
+        if (connections[i].name == options.name) {
+          connections.splice(i, 1);
+        }
+      }
+      this.set(StorageType.DatabaseConnections, connections);
+    }
+  }
+}

package/app/core/ConnectionManager.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const entity_1 = require("../database/entity");
+const repository_1 = require("../database/repository");
+const StorageType_1 = require("../enums/StorageType");
+class ConnectionManager {
+    constructor(configManager) {
+        this.schemas = [entity_1.Collection, entity_1.Store, entity_1.Logger];
+        this.subscribers = [];
+        this.migrations = [];
+        this.omitables = ['title', 'description', 'enabled'];
+        this.configManager = configManager;
+        this.options = this.normalize(this.configManager.get(StorageType_1.StorageType.DatabaseConnections));
+        this.registerEntities(this.options);
+        this.registerSubscribers(this.options);
+        this.registerMigrations(this.options);
+        this.dataSource = new typeorm_1.DataSource(this.options[0]);
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.dataSource.initialize();
+        });
+    }
+    isInitialized() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.dataSource.isInitialized;
+        });
+    }
+    getDataSource() {
+        return this.dataSource;
+    }
+    createDataSource(options) {
+        return new typeorm_1.DataSource(this.discardOmitables(options)).initialize();
+    }
+    registerEntities(options) {
+        this.options = options.map(obj => (Object.assign(Object.assign({}, obj), { entities: this.schemas })));
+    }
+    registerSubscribers(options) {
+        this.options = options.map(obj => (Object.assign(Object.assign({}, obj), { subscribers: this.subscribers })));
+    }
+    registerMigrations(options) {
+        this.options = options.map(obj => (Object.assign(Object.assign({}, obj), { migrations: this.migrations })));
+    }
+    discardOmitables(options) {
+        return Object.fromEntries(Object.entries(options).filter(([key]) => !this.omitables.includes(key)));
+    }
+    normalize(options) {
+        return options.filter((item) => this.discardOmitables(item)).filter((item) => item.enabled);
+    }
+    /**
+     * Proxy methods
+     */
+    getCollection() {
+        return this.dataSource.getRepository(entity_1.Collection);
+    }
+    getLogger() {
+        return this.dataSource.getRepository(entity_1.Logger);
+    }
+    getStore() {
+        return this.dataSource.getRepository(entity_1.Store);
+    }
+    getCollectionRepository() {
+        return this.getCollection().extend(repository_1.CollectionRepository);
+    }
+    getLoggerRepository() {
+        return this.getLogger().extend(repository_1.LoggerRepository);
+    }
+    getStoreRepository() {
+        return this.getStore().extend(repository_1.StoreRepository);
+    }
+}
+exports.default = ConnectionManager;
+//# sourceMappingURL=ConnectionManager.js.map

package/app/core/ConnectionManager.ts

@@ -0,0 +1,95 @@
+import { DataSource, DataSourceOptions } from 'typeorm'
+import { Collection, Store, Logger } from '../database/entity';
+import { CollectionRepository, LoggerRepository, StoreRepository } from '../database/repository';
+import ConfigManager from './ConfigManager';
+import { StorageType } from '../enums/StorageType';
+
+export default class ConnectionManager {
+
+  configManager: ConfigManager;
+  options: DataSourceOptions[];
+  
+  dataSource: DataSource;
+
+  schemas: any[] = [Collection, Store, Logger];
+  subscribers: any[] = []
+  migrations: any[] = [];
+
+  omitables: any[] = ['title', 'description', 'enabled'];
+
+  constructor(configManager: ConfigManager) {
+    this.configManager = configManager;
+
+    this.options = this.normalize(this.configManager.get(StorageType.DatabaseConnections));
+
+    this.registerEntities(this.options);
+    this.registerSubscribers(this.options);
+    this.registerMigrations(this.options);
+
+    this.dataSource = new DataSource(this.options[0]);
+  }
+
+  async initialize() {
+    return await this.dataSource.initialize();
+  }
+
+  async isInitialized() {
+    return this.dataSource.isInitialized;
+  }
+
+  getDataSource(): DataSource {
+    return this.dataSource;
+  }
+
+  createDataSource(options: DataSourceOptions) {
+    return new DataSource(this.discardOmitables(options)).initialize()
+  }
+
+  registerEntities(options: DataSourceOptions[]) {
+    this.options = options.map(obj => ({ ...obj, entities: this.schemas }))
+  }
+
+  registerSubscribers(options: DataSourceOptions[]) {
+    this.options = options.map(obj => ({ ...obj, subscribers: this.subscribers }))
+  }
+
+  registerMigrations(options: DataSourceOptions[]) {
+    this.options = options.map(obj => ({ ...obj, migrations: this.migrations }))
+  }
+
+  discardOmitables(options: object | any): object | any {
+    return Object.fromEntries(Object.entries(options).filter(([key]) => !this.omitables.includes(key)));
+  }
+
+  normalize(options: DataSourceOptions[]) {
+    return options.filter((item: DataSourceOptions) => this.discardOmitables(item)).filter((item: any) => item.enabled)
+  }
+
+  /**
+   * Proxy methods 
+   */
+
+  getCollection() {
+    return this.dataSource.getRepository(Collection)
+  }
+
+  getLogger() {
+    return this.dataSource.getRepository(Logger)
+  }
+
+  getStore() {
+    return this.dataSource.getRepository(Store)
+  }
+
+  getCollectionRepository() {
+    return this.getCollection().extend(CollectionRepository);
+  }
+
+  getLoggerRepository() {
+    return this.getLogger().extend(LoggerRepository);
+  }
+
+  getStoreRepository() {
+    return this.getStore().extend(StoreRepository);
+  }
+}

package/app/core/FontCatalog.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs/promises");
+const path = require('path');
+const exec = require('child_process').exec;
+const child = require('child_process').execFile;
+class FontCatalog {
+    constructor(systemManager) {
+        this.systemManager = systemManager;
+    }
+    createCatalog(folder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield fs.mkdir(folder, { recursive: true });
+        });
+    }
+    commandHelp(done) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield child(this.systemManager.getExecutable(), ['-h'], done);
+        });
+    }
+    findFonts(src, done) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield child(this.systemManager.getExecutable(), ['fonts', 'find', '--root', src], done);
+        });
+    }
+    copyFiles(files, dest, done) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cmdPath = this.systemManager.getExecutable();
+            const items = files.map((item) => `"${path.normalize(item)}"`).join(" ");
+            const command = `${cmdPath} copy files --destination "${dest}" ${items}`;
+            return exec(command, done);
+        });
+    }
+    copyFolders(src, dest, done) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = ['copy', 'folders', '--source', src, '--destination', dest];
+            return child(this.systemManager.getExecutable(), params, done);
+        });
+    }
+}
+exports.default = FontCatalog;
+//# sourceMappingURL=FontCatalog.js.map

package/app/core/FontCatalog.ts

@@ -0,0 +1,42 @@
+import SystemManager from './SystemManager';
+import * as fs from 'fs/promises';
+
+const path = require('path');
+const exec = require('child_process').exec;
+const child = require('child_process').execFile;
+
+export default class FontCatalog {
+
+  systemManager: SystemManager;
+
+  constructor(
+    systemManager: SystemManager,
+  ) {
+    this.systemManager = systemManager;
+  }
+
+  async createCatalog(folder: string): Promise<string> {
+    return await fs.mkdir(folder, { recursive: true });
+  }
+
+  async commandHelp(done: any) {
+    return await child(this.systemManager.getExecutable(), ['-h'], done);
+  }
+
+  async findFonts(src: string, done: any) {
+    return await child(this.systemManager.getExecutable(), ['fonts', 'find', '--root', src], done);
+  }
+
+  async copyFiles(files: any, dest: string, done: any) {
+    const cmdPath = this.systemManager.getExecutable();
+    const items = files.map((item: string) => `"${path.normalize(item)}"`).join(" ");
+    const command = `${cmdPath} copy files --destination "${dest}" ${items}`;
+    return exec(command, done);
+  }
+
+  async copyFolders(src: string, dest: string, done: any) {
+    const params = ['copy', 'folders', '--source', src, '--destination', dest];
+
+    return child(this.systemManager.getExecutable(), params, done);
+  }
+}

package/app/core/FontFinder.js

@@ -0,0 +1,86 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const FontObject_1 = require("./FontObject");
+const fs = require("fs");
+const path = require("path");
+const mimes_1 = require("../config/mimes");
+const prettyBytes = require("pretty-bytes");
+const mime = require("mime");
+// https://stackoverflow.com/questions/10049557/reading-all-files-in-a-directory-store-them-in-objects-and-send-the-object
+class FileSystem {
+    constructor(connectionManager) {
+        this.counter = 0;
+        this.errors = [];
+        this.found = [];
+        this.connectionManager = connectionManager;
+        this.counter = 0;
+        this.errors = [];
+    }
+    setCounter(count) {
+        this.counter = count;
+    }
+    getCounter() {
+        return this.counter;
+    }
+    scanFolders(dir, options, done) {
+        fs.readdir(dir, (err, list) => {
+            if (err)
+                return done(err);
+            let i = 0;
+            let next = () => {
+                let file = list[i++];
+                if (!file)
+                    return done(null, this);
+                let fp = path.resolve(dir, file);
+                fs.stat(fp, (err, stat) => __awaiter(this, void 0, void 0, function* () {
+                    if (stat && stat.isDirectory()) {
+                        this.scanFolders(fp, options, (err, res) => next());
+                    }
+                    else {
+                        this.fontInstall(fp, stat, options);
+                        next();
+                    }
+                }));
+            };
+            next();
+        });
+    }
+    scanFiles(files, options, done) {
+        files.forEach((fp) => __awaiter(this, void 0, void 0, function* () {
+            let stat = fs.statSync(fp);
+            if (stat.isFile()) {
+                this.fontInstall(fp, stat, options);
+            }
+        }));
+        return done(null, this);
+    }
+    fontInstall(fp, stat, options) {
+        let font = new FontObject_1.default(fp);
+        if (font.hasError()) {
+            this.errors.push(font.getError());
+        }
+        else {
+            let fileSize = stat.size;
+            let fileType = mime.getType(fp);
+            let data = Object.assign({ file_path: fp, file_name: path.basename(fp), file_size: fileSize, file_size_pretty: prettyBytes(fileSize), file_type: fileType, installable: mimes_1.installable.includes(fileType) }, options);
+            try {
+                this.connectionManager.getStoreRepository().create(Object.assign(Object.assign({}, data), font.getNamesTable()));
+            }
+            catch (err) {
+                this.errors.push(err.message);
+            }
+            this.counter++;
+        }
+    }
+}
+exports.default = FileSystem;
+//# sourceMappingURL=FontFinder.js.map