fontastic 0.1.3

package/src/app/app.component.ts

@@ -0,0 +1,37 @@
+import { Component, OnInit, ElementRef } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { delay } from 'rxjs/operators';
+import { ConfigService, PresentationService } from './core/services';
+import { gsap } from 'gsap';
+import { ScrollToPlugin } from 'gsap/ScrollToPlugin';
+
+gsap.registerPlugin(ScrollToPlugin);
+
+@Component({
+  selector: 'app-root',
+  templateUrl: './app.component.html',
+  styleUrls: ['./app.component.scss']
+})
+export class AppComponent implements OnInit {
+
+  constructor(
+    private translate: TranslateService,
+    private configService: ConfigService,
+    private presentationService: PresentationService,
+    private el: ElementRef
+  ) {
+    this.translate.setDefaultLang('en');
+    this.presentationService._systemLoading.pipe(delay(2e3)).subscribe(() => this.init());
+    this.configService.set('ng-version', this.el.nativeElement.getAttribute('ng-version'));
+  }
+
+  ngOnInit(): void {
+    const plugins = [ScrollToPlugin];
+  }
+
+  init(): void {
+    const body = document.querySelector('body');
+    body.classList.remove('app-loading');
+    body.classList.add('app-loaded');
+  }
+}

package/src/app/app.module.ts

@@ -0,0 +1,63 @@
+import 'reflect-metadata';
+import '../polyfills';
+
+import { BrowserModule } from '@angular/platform-browser';
+import { NgModule, APP_INITIALIZER } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { HttpClientModule, HttpClient } from '@angular/common/http';
+
+// NG Translate
+import { TranslateModule, TranslateLoader } from '@ngx-translate/core';
+import { TranslateHttpLoader } from '@ngx-translate/http-loader';
+
+import { AppComponent } from './app.component';
+
+import { CoreModule } from './core/core.module';
+import { SharedModule } from './shared/shared.module';
+import { LayoutModule } from './layout/layout.module';
+import { MainModule } from './pages/main/main.module';
+import { AppRoutingModule } from './app-routing.module';
+
+import { BootService } from '@app/core/services';
+
+// AoT requires an exported function for factories
+export function httpLoaderFactory(http: HttpClient): TranslateHttpLoader {
+  return new TranslateHttpLoader(http, './assets/i18n/', '.json');
+}
+
+@NgModule({
+  declarations: [
+    AppComponent
+  ],
+  imports: [
+    BrowserModule,
+    FormsModule,
+    ReactiveFormsModule,
+    HttpClientModule,
+    CoreModule,
+    SharedModule,
+    LayoutModule,
+    MainModule,
+    AppRoutingModule,
+    TranslateModule.forRoot({
+      loader: {
+        provide: TranslateLoader,
+        useFactory: httpLoaderFactory,
+        deps: [HttpClient]
+      }
+    })
+  ],
+  providers: [
+    BootService,
+    { 
+      provide: APP_INITIALIZER, 
+      useFactory: (bootService: BootService) => () => bootService.init(), 
+      deps: [BootService], 
+      multi: true 
+    }
+  ],
+  bootstrap: [AppComponent]
+})
+export class AppModule {
+
+}

package/src/app/core/core.module.ts

@@ -0,0 +1,11 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule
+  ],
+  providers: []
+})
+export class CoreModule { }

package/src/app/core/model/AuthUserModel.ts

@@ -0,0 +1,7 @@
+export class AuthUserModel {
+  constructor(
+    public name: string = '',
+    public email: string = '',
+    public status: string = '',
+  ) { }
+}

package/src/app/core/model/CustomThemeModel.ts

@@ -0,0 +1,7 @@
+export class CustomThemeModel {
+  constructor(
+    public key: string = '',
+    public title: string = '',
+    public description: string = '',
+  ) { }
+}

package/src/app/core/model/DbConnectionModel.ts

@@ -0,0 +1,16 @@
+export class DbConnectionModel {
+
+  constructor(
+    public name: string = '',
+    public title: string = '',
+    public description: string = '',
+    public type: string = '',
+    public database: string,
+    public username: string = '',
+    public password: string = '',
+    public host: string = '',
+    public port: string = '',
+    public logging: boolean = false,
+    public synchronize: boolean = false
+  ) { }
+}

package/src/app/core/model/ImportOptionsModel.ts

@@ -0,0 +1,5 @@
+export class ImportOptionsModel {
+  constructor(
+    public type: string,
+  ) { }
+}

package/src/app/core/model/LatestNewsModel.ts

@@ -0,0 +1,7 @@
+export class LatestNewsModel {
+  constructor(
+    public ts: number = 0,
+    public artiles: any[] = [],
+    public apiKey: string = '',
+  ) { }
+}

package/src/app/core/model/SearchFormModel.ts

@@ -0,0 +1,10 @@
+
+export class SearchFormModel {
+  constructor(
+    public term: string = '',
+    public mimes: any[] = [],
+    public sort: string = 'id',
+    public order: string = 'ASC',
+    public activated: boolean = false
+  ) { }
+}

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

@@ -0,0 +1,6 @@
+export * from './CustomThemeModel';
+export * from './AuthUserModel';
+export * from './DbConnectionModel';
+export * from './LatestNewsModel';
+export * from './SearchFormModel';
+export * from './ImportOptionsModel';

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

@@ -0,0 +1,22 @@
+import { waitForAsync, TestBed } from '@angular/core/testing';
+import { RouterTestingModule } from '@angular/router/testing';
+import { AlertService } from './alert.service';
+
+describe('AlertService', () => {
+
+  beforeEach(waitForAsync(() => {
+    TestBed.configureTestingModule({
+      imports: [
+        RouterTestingModule
+      ],
+      providers: [{
+        provide: AlertService,
+      }]
+    });
+  }));
+
+  it('should be created', () => {
+    const service: AlertService = TestBed.inject(AlertService);
+    expect(service).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+import { Router, NavigationStart } from '@angular/router';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { AppAlert } from '@main/types';
+import { AlertTypes, AlertTimeout, AlertProps } from '@main/config/alert';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AlertService {
+
+  _alert = new BehaviorSubject<AppAlert>(null);
+  watchAlert$ = this._alert.asObservable();
+
+  constructor(
+    private router: Router
+  ) {
+    this.router.events.subscribe(event => {
+      if (event instanceof NavigationStart) {
+        this.clear();
+      }
+    });
+  }
+
+  getObservable(): Observable<AppAlert> {
+    return this._alert.asObservable();
+  }
+
+  getAlert(): AppAlert {
+    return this._alert.getValue();
+  }
+
+  setAlert(values: AppAlert): void {
+    this._alert.next(values);
+  }
+
+  send(type: string, message: string, timeout: number = AlertTimeout, keep: boolean = false): void {
+    const alert = AlertTypes.find((item: any) => item.type === type);
+    if (alert) {
+      this.setAlert({ type, message, timeout, keep, ...alert });
+    }
+  }
+
+  info(message: string, timeout: number = AlertTimeout, keep: boolean = false): void {
+    this.send('info', message, timeout, keep);
+  }
+
+  success(message: string, timeout: number = AlertTimeout, keep: boolean = false): void {
+    this.send('success', message, timeout, keep);
+  }
+
+  error(message: string, timeout: number = AlertTimeout, keep: boolean = false): void {
+    this.send('error', message, timeout, keep);
+  }
+
+  warning(message: string, timeout: number = AlertTimeout, keep: boolean = false): void {
+    this.send('warning', message, timeout, keep);
+  }
+
+  danger(message: string, timeout: number = AlertTimeout, keep: boolean = false): void {
+    this.send('danger', message, timeout, keep);
+  }
+
+  clear(): void {
+    this._alert.next(AlertProps);
+  }
+
+  dismiss() {
+    setTimeout(() => this.clear(), this.getAlert().timeout);
+  }
+}

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

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { AuthUser } from '@main/types';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AuthService {
+
+  _authUser = new BehaviorSubject<AuthUser>(null);
+  watchAuthUser$ = this._authUser.asObservable();
+
+  constructor() { }
+
+  get authUserValue(): AuthUser {
+    return this._authUser.value;
+  }
+
+  setAuthUser(data: AuthUser): void {
+    this._authUser.next(data);
+  }
+
+  getAuthUser(): AuthUser {
+    return this._authUser.getValue();
+  }
+
+  logout(): void {
+    this._authUser.next(null);
+  }
+}

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

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { AuthService, ConfigService, ElectronService, MessageService } from '@app/core/services';
+import { SystemConfig } from '@main/types';
+
+@Injectable()
+export class BootService {
+
+  constructor(
+    private authService: AuthService,
+    private configService: ConfigService,
+    private messageService: MessageService,
+    private electronService: ElectronService
+  ) { }
+
+  public init() {
+    return new Promise((resolve, reject) => {
+      if (this.electronService.isElectron) {
+        this.messageService.systemBoot().then((result: SystemConfig) => {
+          this.configService.setConfig(result);
+          if (result?.user) {
+            this.authService.setAuthUser(result.user);
+          }
+          if (result?.system?.is_dev) {
+            this.configService.debug();
+          }
+          resolve(result);
+        }).catch((err: Error) => reject(err));
+      } else {
+        resolve(true);
+      }
+    });
+  }
+}

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

@@ -0,0 +1,22 @@
+import { waitForAsync, TestBed } from '@angular/core/testing';
+import { RouterTestingModule } from '@angular/router/testing';
+import { BreadcrumbService } from './breadcrumb.service';
+
+describe('BreadcrumbService', () => {
+
+  beforeEach(waitForAsync(() => {
+    TestBed.configureTestingModule({
+      imports: [
+        RouterTestingModule
+      ],
+      providers: [{
+        provide: BreadcrumbService,
+      }]
+    });
+  }));
+
+  it('should be created', () => {
+    const service: BreadcrumbService = TestBed.inject(BreadcrumbService);
+    expect(service).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { Breadcrumb } from '@main/types';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BreadcrumbService {
+
+  private _breadcrumb$ = new Subject<Breadcrumb[]>();
+
+  getObservable(): Observable<Breadcrumb[]> {
+    return this._breadcrumb$.asObservable();
+  }
+
+  set(results: Breadcrumb[] = []) {
+    this._breadcrumb$.next(results);
+  }
+
+  setNavigation(collectionId: number, results: any[], items: Breadcrumb[] = []) {
+    const found = results.filter((item: any) => item.id === collectionId);
+
+    if (found.length) {
+      items.push({ title: found[0].title, link: '', type: 'collection' });
+      return this.setNavigation(found[0].parent_id, results, items);
+    }
+
+    return this.set(items.reverse());
+  }
+}

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

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { getProperty, setProperty, hasProperty, deleteProperty } from 'dot-prop';
+import { SystemConfig } from '@main/types';
+import { StorageType } from '@main/enums';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ConfigService {
+
+  _systemConfig = new BehaviorSubject<SystemConfig>(null);
+  watchSystemConfig$ = this._systemConfig.asObservable();
+
+  setConfig(values: SystemConfig): void {
+    this._systemConfig.next(values);
+  }
+
+  getConfig(): SystemConfig {
+    return this._systemConfig.getValue();
+  }
+
+  set(key: string, value: any): any {
+    const config: any = this.getConfig();
+    return setProperty(config, key, value);
+  }
+
+  get(key: string): any {
+    const config = this.getConfig();
+    return getProperty(config, key);
+  }
+
+  has(key: string): boolean {
+    const config: any = this.getConfig();
+    return hasProperty(config, key);
+  }
+
+  delete(key: string): boolean {
+    const config: any = this.getConfig();
+    return deleteProperty(config, key);
+  }
+
+  debug() {
+    const config: SystemConfig = this.getConfig();
+    console.log(config);
+  }
+
+  /**
+   * Proxy methods.
+   */
+
+  getIsProduction(): boolean {
+    return this.get(StorageType.System)?.is_production;
+  }
+
+  getIsWindows(): boolean {
+    return this.get(StorageType.System)?.is_windows;
+  }
+
+  getSystemVersion(): boolean {
+    return this.get(StorageType.System)?.version;
+  }
+}