fontastic 0.1.3

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

@@ -0,0 +1,289 @@
+import { Injectable } from '@angular/core';
+import { ElectronService } from '@app/core/services/electron/electron.service';
+import { Collection } from '@main/database/entity/Collection.schema';
+import { Logger } from '@main/database/entity/Logger.schema';
+import { Store, StoreManyAndCountType } from '@main/database/entity/Store.schema';
+import { ChannelType } from '@main/enums';
+import { SystemConfig, SystemStats } from '@main/types';
+import { IpcMainEvent } from 'electron';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MessageService {
+
+  constructor(
+    private electron: ElectronService
+  ) { }
+
+  on(channel: string, listener: any): Electron.IpcRenderer {
+    if (this.electron.isElectron) {
+      return this.electron.ipcRenderer.on(channel, listener);
+    }
+  }
+
+  once(channel: string, listener: any): Electron.IpcRenderer {
+    if (this.electron.isElectron) {
+      return this.electron.ipcRenderer.once(channel, listener);
+    }
+  }
+
+  send(channel: string, args?: any): void {
+    if (this.electron.isElectron) {
+      this.electron.ipcRenderer.send(channel, args);
+    }
+  }
+
+  invoke(channel: string, args?: any): Promise<any> {
+    if (this.electron.isElectron) {
+      return this.electron.ipcRenderer.invoke(channel, args);
+    }
+  }
+
+  removeListener(channel: string, listener: any): Electron.IpcRenderer {
+    if (this.electron.isElectron) {
+      return this.electron.ipcRenderer.removeListener(channel, listener);
+    }
+  }
+
+  removeAllListeners(channel: string): Electron.IpcRenderer {
+    if (this.electron.isElectron) {
+      return this.electron.ipcRenderer.removeAllListeners(channel);
+    }
+  }
+
+  systemBoot(): Promise<SystemConfig> {
+    this.send(ChannelType.IPC_REQUEST_SYSTEM_BOOT);
+    return new Promise((resolve, _reject) => {
+      this.once(ChannelType.IPC_RESPONSE_SYSTEM_BOOT, (_event: IpcMainEvent, response: any) => {
+        resolve(response);
+      });
+    });
+  }
+
+  systemReboot(): void {
+    this.send(ChannelType.IPC_SYSTEM_REBOOT);
+  }
+
+  // Config Manager
+
+  set(key: string, values: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_SET_CONFIG, { key, values });
+  }
+
+  get(key: string, values: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_GET_CONFIG, { key, values });
+  }
+
+  clearStore(): Promise<any> {
+    return this.invoke(ChannelType.IPC_ZAP_CONFIG);
+  }
+
+  // Connection Manager
+
+  createDbConnection(args: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_DBCONNECTION_CREATE, args);
+  }
+
+  enableDbConnection(args: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_DBCONNECTION_ENABLE, args);
+  }
+
+  deleteDbConnection(name: string): Promise<any> {
+    return this.invoke(ChannelType.IPC_DBCONNECTION_DELETE, name);
+  }
+
+  testDbConnection(item: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_DBCONNECTION_TEST, item);
+  }
+
+  dropDatabase(): Promise<any> {
+    return this.invoke(ChannelType.IPC_DATABASE_DROP);
+  }
+
+  // Font Manager
+
+  exec(args: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_EXEC_CMD, args);
+  }
+
+  systemAuthenticate(args: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_AUTH_USER, args);
+  }
+
+  scanFiles(args: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_SCAN_FILES, args);
+  }
+
+  scanFolders(args: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_SCAN_FOLDERS, args);
+  }
+
+  fontActivation(args: any): Promise<Store[]> {
+    return this.invoke(ChannelType.IPC_ACTIVATE_FONT, args);
+  }
+
+  folderActivation(args: any): Promise<Store[]> {
+    return this.invoke(ChannelType.IPC_ACTIVATE_FOLDER, args);
+  }
+
+  fetchLatestNews(args: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_FETCH_NEWS, args);
+  }
+
+  showMessageBox(args: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_SHOW_MESSAGE_BOX, args);
+  }
+
+  showOpenDialog(args: any): Promise<any> {
+    return this.invoke(ChannelType.IPC_SHOW_OPEN_DIALOG, args);
+  }
+
+  openPath(path: string): Promise<any> {
+    return this.invoke(ChannelType.IPC_OPEN_PATH, path);
+  }
+
+  showItemInFolder(path: string): Promise<any> {
+    return this.invoke(ChannelType.IPC_OPEN_FOLDER, path);
+  }
+
+  openExternal(url: string): Promise<any> {
+    return this.invoke(ChannelType.IPC_OPEN_EXTERNAL, url);
+  }
+
+  reloadWindow(): void {
+    this.send(ChannelType.IPC_RELOAD_WINDOW);
+  }
+
+  quitApplication(): void {
+    this.send(ChannelType.IPC_QUIT);
+  }
+
+  exitApplication(): void {
+    this.send(ChannelType.IPC_EXIT);
+  }
+
+  beep(): void {
+    this.send(ChannelType.IPC_BEEP);
+  }
+
+  // Collection
+
+  collectionFind(args: any): Promise<Collection[]> {
+    return this.invoke(ChannelType.IPC_COLLECTION_FIND, args);
+  }
+
+  collectionFindOne(args: any): Promise<Collection> {
+    return this.invoke(ChannelType.IPC_COLLECTION_FIND_ONE, args);
+  }
+
+  collectionFindOneBy(args: any): Promise<Collection> {
+    return this.invoke(ChannelType.IPC_COLLECTION_FIND_ONE_BY, args);
+  }
+
+  collectionFetch(args: any): Promise<Collection[]> {
+    return this.invoke(ChannelType.IPC_COLLECTION_FETCH, args);
+  }
+
+  collectionCreate(args: any): Promise<Collection[]> {
+    return this.invoke(ChannelType.IPC_COLLECTION_CREATE, args);
+  }
+
+  collectionUpdate(collectionId: number, data: any): Promise<Collection[]> {
+    return this.invoke(ChannelType.IPC_COLLECTION_UPDATE, { collectionId, data });
+  }
+
+  collectionUpdateIds(ids: any[], data: any): Promise<Collection[]> {
+    return this.invoke(ChannelType.IPC_COLLECTION_UPDATE_IDS, { ids, data });
+  }
+
+  collectionDelete(collectionId: number): Promise<Collection[]> {
+    return this.invoke(ChannelType.IPC_COLLECTION_DELETE, { collectionId });
+  }
+
+  collectionEnable(collectionId: number, data: any): Promise<Collection[]> {
+    return this.invoke(ChannelType.IPC_COLLECTION_ENABLE, { collectionId, data });
+  }
+
+  collectionUpdateCount(id: number): Promise<Collection[]> {
+    return this.invoke(ChannelType.IPC_COLLECTION_UPDATE_COUNT, id);
+  }
+
+  collectionUpdateCounts(): Promise<Collection[]> {
+    return this.invoke(ChannelType.IPC_COLLECTION_UPDATE_COUNTS);
+  }
+
+  // Store
+
+  storeFind(args: any): Promise<Store[]> {
+    return this.invoke(ChannelType.IPC_STORE_FIND, args);
+  }
+
+  storeFindOne(args: any): Promise<Store> {
+    return this.invoke(ChannelType.IPC_STORE_FIND_ONE, args);
+  }
+
+  storeFindOneBy(args: any): Promise<Store> {
+    return this.invoke(ChannelType.IPC_STORE_FIND_ONE_BY, args);
+  }
+
+  storeFetch(options: any): Promise<StoreManyAndCountType> {
+    return this.invoke(ChannelType.IPC_STORE_FETCH, options);
+  }
+
+  storeSearch(options: any): Promise<StoreManyAndCountType> {
+    return this.invoke(ChannelType.IPC_STORE_SEARCH, options);
+  }
+
+  storeUpdate(id: number, data: any): Promise<Store> {
+    return this.invoke(ChannelType.IPC_STORE_UPDATE, { id, data });
+  }
+
+  syncSystemFonts(): Promise<SystemStats> {
+    return this.invoke(ChannelType.IPC_STORE_SYNC_SYSTEM);
+  }
+
+  syncActivatedFonts(): Promise<SystemStats> {
+    return this.invoke(ChannelType.IPC_STORE_SYNC_ACTIVATED);
+  }
+
+  resetFavorites(): Promise<SystemStats> {
+    return this.invoke(ChannelType.IPC_STORE_RESET_FAVORITES);
+  }
+
+  fetchSystemStats(): Promise<SystemStats> {
+    return this.invoke(ChannelType.IPC_STORE_SYSTEM_STATS);
+  }
+
+  /**
+   * Logger
+   */
+
+  log(message: string, type: number): Promise<Logger[]> {
+    return this.loggerCreate(message, type);
+  }
+
+  loggerFind(args: any): Promise<Logger[]> {
+    return this.invoke(ChannelType.IPC_LOGGER_FIND, args);
+  }
+
+  loggerFindOne(args: any): Promise<Logger> {
+    return this.invoke(ChannelType.IPC_LOGGER_FIND_ONE, args);
+  }
+
+  loggerFindOneBy(args: any): Promise<Logger> {
+    return this.invoke(ChannelType.IPC_LOGGER_FIND_ONE_BY, args);
+  }
+
+  loggerCreate(message: string, type: number): Promise<Logger[]> {
+    return this.invoke(ChannelType.IPC_LOGGER_CREATE, { message, type });
+  }
+
+  loggerDelete(id: number): Promise<Logger[]> {
+    return this.invoke(ChannelType.IPC_LOGGER_DELETE, { id });
+  }
+
+  loggerTruncate(): Promise<Logger[]> {
+    return this.invoke(ChannelType.IPC_LOGGER_TRUNCATE);
+  }
+}

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

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

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

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { ModalComponent } from '@app/shared/components';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ModalService {
+
+  private modals: ModalComponent[] = [];
+
+  add(modal: ModalComponent): void {
+    if (!modal.id) {
+      throw new Error('Modal components must have a unique id attribute.');
+    }
+
+    if (!this.modals.find((item: ModalComponent) => item.id === modal.id)) {
+      this.modals.push(modal);
+    }
+  }
+
+  remove(modal: ModalComponent): void {
+    this.modals = this.modals.filter((item: ModalComponent) => item === modal);
+  }
+
+  open(id: string): void {
+    const modal = this.modals.find((item: ModalComponent) => item.id === id);
+    modal?.open();
+  }
+
+  close(): void {
+    const modal = this.modals.find((item: ModalComponent) => item.enabled);
+    modal?.close();
+  }
+}

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

@@ -0,0 +1,94 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ConfigService } from '@app/core/services/config/config.service';
+import { MessageService } from '@app/core/services/message/message.service';
+import { LatestNewsModel } from '@app/core/model/LatestNewsModel';
+import { StorageType } from '@main/enums';
+import { NewsType } from '@main/types';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NewsService {
+
+  oneHour = 60 * 60 * 1000;
+
+  endpoints: any = {
+    sources: 'https://newsapi.org/v2/top-headlines/sources?country=us&apiKey=',
+    articles: 'https://newsapi.org/v2/top-headlines?country=us&apiKey=',
+    business: 'https://newsapi.org/v2/top-headlines?country=us&category=business&apiKey='
+  };
+
+  _latestNews = new BehaviorSubject(new LatestNewsModel());
+  watchLatestNews$ = this._latestNews.asObservable();
+
+  constructor(
+    private configService: ConfigService,
+    private messageService: MessageService
+  ) {
+    if (this.configService.has(StorageType.News)) {
+      this.setLatestNews(this.configService.get(StorageType.News));
+    }
+
+    this.fetchLatestNews();
+  }
+
+  get currentTime(): number {
+    return Date.now();
+  }
+
+  get timeUTCString(): string {
+    return new Date(this.currentTime).toUTCString();
+  }
+
+  getLatestNews() {
+    return this._latestNews.getValue();
+  }
+
+  setLatestNews(items: any = []) {
+    this._latestNews.next(items);
+  }
+
+  checkTime(timeStamp: number): boolean {
+    return (timeStamp + this.oneHour) < this.currentTime;
+  }
+
+  getApiKey() {
+    return this.hasApiKey() ? this.getLatestNews().apiKey : false;
+  }
+
+  hasApiKey() {
+    return this.getLatestNews().apiKey ? true : false;
+  }
+
+  async fetchLatestNews(skipTimeCheck: boolean = false) {
+    if (!this.hasApiKey()) {
+      return;
+    }
+
+    const news = this.getLatestNews();
+
+    if (skipTimeCheck) {
+      return await this.sendRequest();
+    } else if (this.checkTime(news.ts)) {
+      return await this.sendRequest();
+    }
+  }
+
+  async sendRequest() {
+    const response: NewsType = await this.messageService.fetchLatestNews({
+      endpoint: this.endpoints.business + this.getApiKey()
+    });
+    
+    if (response?.status === 'ok') {
+      const saved = { ts: this.currentTime, articles: response.articles, apiKey: this.getLatestNews().apiKey };
+      this.setLatestNews(saved);
+      this.messageService.set(StorageType.News, saved);
+      this.messageService.log(`Updated news at: ${this.timeUTCString}`, 1);
+    } else {
+      this.messageService.log('Failed to fetch news articles.', 1);
+    }
+
+    return response;
+  }
+}