tin-spa 2.13.14 → 9.0.0

package/esm2015/lib/modules/spa-mat.module.js

@@ -0,0 +1,53 @@
+import { __decorate } from "tslib";
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatBadgeModule } from '@angular/material/badge';
+import { MatButtonModule } from '@angular/material/button';
+import { MatCardModule } from '@angular/material/card';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatNativeDateModule, MAT_DATE_LOCALE } from '@angular/material/core';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatDialogModule, MAT_DIALOG_DEFAULT_OPTIONS } from '@angular/material/dialog';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatListModule } from '@angular/material/list';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatPaginatorModule } from '@angular/material/paginator';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatRadioModule } from '@angular/material/radio';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatSortModule } from '@angular/material/sort';
+import { MatStepperModule } from '@angular/material/stepper';
+import { MatTableModule } from '@angular/material/table';
+import { MatTabsModule } from '@angular/material/tabs';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { ReactiveFormsModule, FormsModule } from '@angular/forms';
+const ɵ0 = { disableClose: true, hasBackdrop: true };
+let SpaMatModule = class SpaMatModule {
+};
+SpaMatModule = __decorate([
+    NgModule({
+        declarations: [],
+        imports: [],
+        exports: [
+            CommonModule, FormsModule, ReactiveFormsModule,
+            MatMenuModule, MatSliderModule, MatTableModule, MatPaginatorModule,
+            MatCheckboxModule, MatBadgeModule, MatButtonModule, MatIconModule, MatDialogModule, MatSnackBarModule,
+            MatTabsModule, MatFormFieldModule, MatInputModule, MatCardModule, MatChipsModule, MatSelectModule,
+            MatNativeDateModule, MatProgressSpinnerModule, MatListModule, MatAutocompleteModule, MatTooltipModule, MatSortModule,
+            MatDatepickerModule, MatStepperModule, MatRadioModule,
+        ],
+        providers: [
+            { provide: MAT_DIALOG_DEFAULT_OPTIONS, useValue: ɵ0 },
+            { provide: MAT_DATE_LOCALE, useValue: "en-GB" },
+        ]
+    })
+], SpaMatModule);
+export { SpaMatModule };
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/modules/spa-user.module.js

@@ -0,0 +1,31 @@
+import { __decorate } from "tslib";
+import { SpaMatModule } from "./spa-mat.module";
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { ChangePasswordComponent } from "../components/change-password/change-password.component";
+import { ProfileComponent } from "../components/profile/profile.component";
+let SpaUserModule = class SpaUserModule {
+};
+SpaUserModule = __decorate([
+    NgModule({
+        declarations: [ChangePasswordComponent, ProfileComponent],
+        entryComponents: [],
+        imports: [
+            ReactiveFormsModule.withConfig({ warnOnNgModelWithFormControl: "never" }),
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            SpaMatModule,
+        ],
+        exports: [
+            CommonModule,
+            FormsModule,
+            SpaMatModule,
+            ChangePasswordComponent,
+            ProfileComponent,
+        ],
+    })
+], SpaUserModule);
+export { SpaUserModule };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/auth.service.js

@@ -0,0 +1,153 @@
+import { __decorate } from "tslib";
+import { MessageService } from './message.service';
+//-----------------Change for Build and Reference purposes for SERVICES ONLY---------//
+import { Constants, HttpService } from 'tin-core';
+// import { HttpService, Constants } from 'tin-core';
+//----------------------------------------------------------------------------------//
+import { Injectable } from '@angular/core';
+import { Router, CanActivate } from '@angular/router';
+import { BehaviorSubject } from 'rxjs';
+import { StorageService } from './storage.service';
+import { LogService } from './log.service';
+import { Role } from '../classes/Classes';
+import * as i0 from "@angular/core";
+import * as i1 from "./storage.service";
+import * as i2 from "@angular/router";
+import * as i3 from "tin-core";
+import * as i4 from "./message.service";
+import * as i5 from "./log.service";
+// import { Constants } from  "tin-core";
+let AuthService = class AuthService {
+    constructor(storage, router, httpService, messageService, logService) {
+        this.storage = storage;
+        this.router = router;
+        this.httpService = httpService;
+        this.messageService = messageService;
+        this.logService = logService;
+        //Logged in
+        this.loggedin = false;
+        this.loggedinSource = new BehaviorSubject(this.loggedin);
+        this.loggedinObserv = this.loggedinSource.asObservable();
+        //Token
+        this.token = "";
+        this.tokenSource = new BehaviorSubject(this.token);
+        this.tokenObserv = this.tokenSource.asObservable();
+        //TokenExpire
+        this.tokenExpire = "";
+        this.tokenExpireSource = new BehaviorSubject(this.tokenExpire);
+        this.tokenExpireObserv = this.tokenExpireSource.asObservable();
+        //Current User
+        this.currentUser = "tnyagato";
+        this.currentUserSource = new BehaviorSubject(this.currentUser);
+        this.currentUserObserv = this.currentUserSource.asObservable();
+        //Line Manager
+        this.islineManager = false;
+        this.isLineManagerSource = new BehaviorSubject(this.islineManager);
+        this.isLineManagerObserv = this.isLineManagerSource.asObservable();
+        //Roles
+        this.currentRole = new Role;
+        this.currentRoleSource = new BehaviorSubject(this.currentRole);
+        this.myRoleObserv = this.currentRoleSource.asObservable();
+        //Logged in FirstName
+        this.loggedUserSource = new BehaviorSubject("tnyagato");
+        this.loggedUserFullName = this.loggedUserSource.asObservable();
+    }
+    updateloggedin(loggedin) {
+        this.loggedinSource.next(loggedin);
+        this.loggedin = loggedin;
+    }
+    updateToken(newToken) {
+        this.tokenSource.next(newToken);
+    }
+    updateTokenExpire(newTokenExpire) {
+        this.tokenExpireSource.next(newTokenExpire);
+    }
+    updateCurrentUser(newUser) {
+        this.currentUserSource.next(newUser.toLocaleLowerCase());
+        this.currentUser = newUser.toLocaleLowerCase();
+    }
+    updateIsLineManager(manager) {
+        this.isLineManagerSource.next(manager);
+    }
+    updateRole(role) {
+        this.currentRoleSource.next(role);
+    }
+    updateLoggedUserFullName(username) {
+        this.loggedUserSource.next(username);
+    }
+    //Authorisation
+    isAuthorised(capName) {
+        if (!this.currentRoleSource.value[capName]) {
+            // this.logService.info(`authorise: ${this.currentRoleSource.value.roleName} not authorised for ${capName}`);
+            this.router.navigate(["home"]);
+            this.messageService.toast(`Unauthorised: ${capName}`);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    isValidToken() {
+        let tokenExpire = new Date(this.tokenExpireSource.value);
+        let nowDate = new Date();
+        let valid = tokenExpire > nowDate;
+        if (!valid) {
+            this.router.navigate(["login"]);
+            this.messageService.toast(`Expired Session`);
+        }
+        return valid;
+    }
+    canActivate() {
+        if (this.loggedin && this.isValidToken()) {
+            // this.logService.info("authentication: logged in");
+            return true;
+        }
+        if (localStorage.getItem(Constants.AUTH_USER) === null) {
+            // this.logService.info("authentication: not logged and no cache");
+            this.updateloggedin(false);
+            this.router.navigate(["login"]);
+            return false;
+        }
+        else {
+            // this.logService.info("authentication: not logged but allowed login");
+            this.updateloggedin(true);
+            this.storage.get(Constants.AUTH_USER).then((resp) => {
+                this.updateCurrentUser(resp);
+                // console.log("user: " + resp);
+            });
+            this.storage.get(Constants.AUTH_NAME).then((resp) => {
+                this.updateLoggedUserFullName(resp);
+                // console.log("name: " + resp);
+            });
+            this.storage.get(Constants.AUTH_ROLES).then((resp) => {
+                let ret = JSON.parse(resp);
+                this.updateRole(ret);
+                // console.log("role: " + ret.roleName);
+            });
+            this.storage.get(Constants.AUTH_TOKEN).then((resp) => {
+                this.updateToken(resp);
+                // console.log("token: " + resp);
+            });
+            this.storage.get(Constants.AUTH_TOKEN_EXPIRE).then((resp) => {
+                this.updateTokenExpire(resp);
+                this.isValidToken();
+            });
+            return true;
+        }
+    }
+};
+AuthService.ctorParameters = () => [
+    { type: StorageService },
+    { type: Router },
+    { type: HttpService },
+    { type: MessageService },
+    { type: LogService }
+];
+AuthService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthService_Factory() { return new AuthService(i0.ɵɵinject(i1.StorageService), i0.ɵɵinject(i2.Router), i0.ɵɵinject(i3.HttpService), i0.ɵɵinject(i4.MessageService), i0.ɵɵinject(i5.LogService)); }, token: AuthService, providedIn: "root" });
+AuthService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    })
+], AuthService);
+export { AuthService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"ng://tin-spa/","sources":["lib/services/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { MessageService } from './message.service';\r\n//-----------------Change for Build and Reference purposes for SERVICES ONLY---------//\r\nimport { Constants, HttpService } from 'tin-core';\r\n// import { HttpService, Constants } from 'tin-core';\r\n//----------------------------------------------------------------------------------//\r\n\r\nimport { Injectable } from '@angular/core';\r\nimport { Router, CanActivate } from '@angular/router';\r\nimport { BehaviorSubject } from 'rxjs';\r\nimport { StorageService } from './storage.service';\r\nimport { LogService } from './log.service';\r\nimport { Role } from '../classes/Classes';\r\n// import { Constants } from  \"tin-core\";\r\n\r\n\r\n\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\n\r\nexport class AuthService implements CanActivate {\r\n  constructor(private storage: StorageService, public router: Router, private httpService: HttpService, private messageService: MessageService, private logService: LogService) {}\r\n\r\n\r\n  //Logged in\r\n  private loggedin: boolean = false;\r\n  private loggedinSource = new BehaviorSubject(this.loggedin);\r\n  public loggedinObserv = this.loggedinSource.asObservable();\r\n  updateloggedin(loggedin: boolean) {\r\n    this.loggedinSource.next(loggedin);\r\n    this.loggedin = loggedin;\r\n  }\r\n\r\n  //Token\r\n  private token: string = \"\";\r\n  public tokenSource = new BehaviorSubject(this.token);\r\n  public tokenObserv = this.tokenSource.asObservable();\r\n  updateToken(newToken: string) {\r\n    this.tokenSource.next(newToken);\r\n\r\n  }\r\n\r\n    //TokenExpire\r\n    private tokenExpire: string = \"\";\r\n    public tokenExpireSource = new BehaviorSubject(this.tokenExpire);\r\n    public tokenExpireObserv = this.tokenExpireSource.asObservable();\r\n    updateTokenExpire(newTokenExpire: string) {\r\n      this.tokenExpireSource.next(newTokenExpire);\r\n\r\n    }\r\n\r\n  //Current User\r\n  public currentUser: string = \"tnyagato\";\r\n  private currentUserSource = new BehaviorSubject(this.currentUser);\r\n  public currentUserObserv = this.currentUserSource.asObservable();\r\n  updateCurrentUser(newUser: string) {\r\n    this.currentUserSource.next(newUser.toLocaleLowerCase());\r\n    this.currentUser = newUser.toLocaleLowerCase();\r\n  }\r\n\r\n  //Line Manager\r\n  private islineManager: boolean = false;\r\n  private isLineManagerSource = new BehaviorSubject(this.islineManager);\r\n  public isLineManagerObserv = this.isLineManagerSource.asObservable();\r\n  updateIsLineManager(manager: boolean) {\r\n    this.isLineManagerSource.next(manager);\r\n  }\r\n\r\n  //Roles\r\n  private currentRole = new Role;\r\n  public currentRoleSource = new BehaviorSubject(this.currentRole);\r\n  public myRoleObserv = this.currentRoleSource.asObservable();\r\n  updateRole(role) {\r\n    this.currentRoleSource.next(role);\r\n  }\r\n\r\n  //Logged in FirstName\r\n  private loggedUserSource = new BehaviorSubject(\"tnyagato\");\r\n  public loggedUserFullName = this.loggedUserSource.asObservable();\r\n  updateLoggedUserFullName(username: string) {\r\n    this.loggedUserSource.next(username);\r\n  }\r\n\r\n\r\n  //Authorisation\r\n  isAuthorised(capName: string): boolean{\r\n\r\n\r\n\r\n    if (!this.currentRoleSource.value[capName]) {\r\n      // this.logService.info(`authorise: ${this.currentRoleSource.value.roleName} not authorised for ${capName}`);\r\n      this.router.navigate([\"home\"]);\r\n      this.messageService.toast(`Unauthorised: ${capName}`);\r\n\r\n      return false;\r\n    }else{\r\n      return true;\r\n    }\r\n\r\n  }\r\n\r\n  isValidToken(){\r\n\r\n\r\n    let tokenExpire: Date = new Date(this.tokenExpireSource.value);\r\n    let nowDate: Date = new Date();\r\n\r\n\r\n    let valid: boolean = tokenExpire > nowDate;\r\n\r\n    if (!valid){\r\n\r\n      this.router.navigate([\"login\"]);\r\n      this.messageService.toast(`Expired Session`);\r\n    }\r\n\r\n    return valid\r\n\r\n  }\r\n\r\n  canActivate() {\r\n\r\n\r\n    if (this.loggedin && this.isValidToken()) {\r\n      // this.logService.info(\"authentication: logged in\");\r\n      return true;\r\n    }\r\n\r\n    if (localStorage.getItem(Constants.AUTH_USER) === null) {\r\n      // this.logService.info(\"authentication: not logged and no cache\");\r\n\r\n      this.updateloggedin(false);\r\n      this.router.navigate([\"login\"]);\r\n      return false;\r\n\r\n    } else {\r\n      // this.logService.info(\"authentication: not logged but allowed login\");\r\n\r\n      this.updateloggedin(true);\r\n\r\n      this.storage.get(Constants.AUTH_USER).then((resp: any) => {\r\n        this.updateCurrentUser(resp);\r\n        // console.log(\"user: \" + resp);\r\n      });\r\n\r\n      this.storage.get(Constants.AUTH_NAME).then((resp: any) => {\r\n        this.updateLoggedUserFullName(resp);\r\n        // console.log(\"name: \" + resp);\r\n      });\r\n\r\n      this.storage.get(Constants.AUTH_ROLES).then((resp) => {\r\n        let ret = JSON.parse(resp);\r\n\r\n        this.updateRole(ret);\r\n        // console.log(\"role: \" + ret.roleName);\r\n      });\r\n\r\n      this.storage.get(Constants.AUTH_TOKEN).then((resp: any) => {\r\n        this.updateToken(resp);\r\n        // console.log(\"token: \" + resp);\r\n      });\r\n\r\n      this.storage.get(Constants.AUTH_TOKEN_EXPIRE).then((resp: any) => {\r\n        this.updateTokenExpire(resp);\r\n        this.isValidToken();\r\n      });\r\n\r\n\r\n      return true;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/services/data.service.js

@@ -0,0 +1,78 @@
+import { __decorate } from "tslib";
+import { AppConfig, HttpService } from 'tin-core';
+import { Injectable } from '@angular/core';
+import { CapItem } from '../classes/Classes';
+import * as i0 from "@angular/core";
+import * as i1 from "tin-core";
+let DataService = class DataService {
+    constructor(httpService) {
+        // httpService.apiUrl = "http://localhost:20503/";
+        // httpService.apiUrl = "http://localhost/basic/";
+        this.httpService = httpService;
+        this.capUsers = new CapItem;
+        // public appConfig = new AppConfig; ///test
+        this.tmpProfileUserID = "";
+        this.capUsers.name = "cap3";
+        this.capUsers.display = "Users";
+        this.capUsers.link = "home/admin/users";
+    }
+    //Users
+    GetUser(by, val) {
+        return this.httpService.Get("Basic/GetUser?by=" + by + "&val=" + val);
+    }
+    UpdateUser(user, action) {
+        return this.httpService.Post("Basic/UpdateUser?action=" + action, user);
+    }
+    login(u) {
+        return this.httpService.Post("Basic/login", u);
+    }
+    changePassword(u) {
+        return this.httpService.Post("Basic/ChangePassword", u);
+    }
+    changePasswordAdmin(u) {
+        return this.httpService.Post("Basic/ChangePasswordAdmin", u);
+    }
+    SelfReset(u) {
+        return this.httpService.Post("Basic/SelfReset", u);
+    }
+    //Roles
+    UpdateRole(role, action) {
+        return this.httpService.Post("Basic/UpdateRole?action=" + action, role);
+    }
+    GetRole(by, val) {
+        return this.httpService.Get("Basic/GetRole?by=" + by + "&val=" + val);
+    }
+    //Account
+    UpdateAccount(account, action) {
+        return this.httpService.Post("Basic/UpdateAccount?action=" + action, account);
+    }
+    //Profile
+    GetProfile(by, val) {
+        return this.httpService.Get("Basic/GetProfile?by=" + by + "&val=" + val);
+    }
+    UpdateProfile(profile, action) {
+        return this.httpService.Post("Basic/UpdateProfile?action=" + action, profile);
+    }
+    //Logs
+    GetLog(by, val) {
+        return this.httpService.Get("Basic/GetLog?by=" + by + "&val=" + val);
+    }
+    //Settings
+    GetSetting(by, val) {
+        return this.httpService.Get("Basic/GetSetting?by=" + by + "&val=" + val);
+    }
+    UpdateSetting(setting, action) {
+        return this.httpService.Post("Basic/UpdateSetting?action=" + action, setting);
+    }
+};
+DataService.ctorParameters = () => [
+    { type: HttpService }
+];
+DataService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DataService_Factory() { return new DataService(i0.ɵɵinject(i1.HttpService)); }, token: DataService, providedIn: "root" });
+DataService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    })
+], DataService);
+export { DataService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/export.service.js

@@ -0,0 +1,29 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import * as FileSaver from 'file-saver';
+import * as XLSX from 'xlsx';
+import * as i0 from "@angular/core";
+let ExportService = class ExportService {
+    constructor() {
+        this.fileType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8';
+        this.fileExtension = '.xlsx';
+    }
+    exportExcel(jsonData, fileName) {
+        const ws = XLSX.utils.json_to_sheet(jsonData);
+        const wb = { Sheets: { 'data': ws }, SheetNames: ['data'] };
+        const excelBuffer = XLSX.write(wb, { bookType: 'xlsx', type: 'array' });
+        this.saveExcelFile(excelBuffer, fileName);
+    }
+    saveExcelFile(buffer, fileName) {
+        const data = new Blob([buffer], { type: this.fileType });
+        FileSaver.saveAs(data, fileName + this.fileExtension);
+    }
+};
+ExportService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ExportService_Factory() { return new ExportService(); }, token: ExportService, providedIn: "root" });
+ExportService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    })
+], ExportService);
+export { ExportService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/loader-interceptor.service.js

@@ -0,0 +1,77 @@
+import { __decorate } from "tslib";
+import { Router } from '@angular/router';
+import { AuthService } from './auth.service';
+import { MessageService } from './message.service';
+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { LoaderService } from './loader.service';
+import { LogService } from './log.service';
+let LoaderInterceptor = class LoaderInterceptor {
+    constructor(loaderService, messageService, authService, router, logService) {
+        this.loaderService = loaderService;
+        this.messageService = messageService;
+        this.authService = authService;
+        this.router = router;
+        this.logService = logService;
+        this.requests = [];
+    }
+    removeRequest(req) {
+        const i = this.requests.indexOf(req);
+        if (i >= 0) {
+            this.requests.splice(i, 1);
+        }
+        this.loaderService.isLoading.next(this.requests.length > 0);
+    }
+    intercept(request, next) {
+        let requestClone = request.clone({
+            setHeaders: {
+                Authorization: "Basic " + btoa(this.authService.currentUser + ":" + this.authService.tokenSource.value)
+                // Authorization: "Basic " + btoa(this.authService.currentUser + ":" + "j5Toszfr@ys")
+            }
+        });
+        this.requests.push(requestClone);
+        if (this.requests.length > 1) {
+            this.logService.info("Multiple connections detected > " + this.requests.length);
+        }
+        // this.logService.info("Executed > " + requestClone.url)
+        this.loaderService.isLoading.next(true);
+        return Observable.create(observer => {
+            const subscription = next.handle(requestClone)
+                .subscribe(event => {
+                if (event instanceof HttpResponse) {
+                    this.removeRequest(requestClone);
+                    observer.next(event);
+                }
+            }, (err) => {
+                this.messageService.toast('error: ' + err.statusText);
+                this.removeRequest(requestClone);
+                observer.error(err);
+                if (err.status === 401) {
+                    //request is unathorised
+                    this.router.navigate(["login"]);
+                }
+            }, () => {
+                this.removeRequest(requestClone);
+                observer.complete();
+            });
+            // remove request from queue when cancelled
+            return () => {
+                this.removeRequest(requestClone);
+                subscription.unsubscribe();
+            };
+        });
+    }
+};
+LoaderInterceptor.ctorParameters = () => [
+    { type: LoaderService },
+    { type: MessageService },
+    { type: AuthService },
+    { type: Router },
+    { type: LogService }
+];
+LoaderInterceptor = __decorate([
+    Injectable()
+], LoaderInterceptor);
+export { LoaderInterceptor };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/loader.service.js

@@ -0,0 +1,17 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+let LoaderService = class LoaderService {
+    constructor() {
+        this.isLoading = new BehaviorSubject(false);
+    }
+};
+LoaderService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LoaderService_Factory() { return new LoaderService(); }, token: LoaderService, providedIn: "root" });
+LoaderService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    })
+], LoaderService);
+export { LoaderService };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290Ijoibmc6Ly90aW4tc3BhLyIsInNvdXJjZXMiOlsibGliL3NlcnZpY2VzL2xvYWRlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxNQUFNLENBQUM7O0FBS3ZDLElBQWEsYUFBYSxHQUExQixNQUFhLGFBQWE7SUFHeEI7UUFETyxjQUFTLEdBQUcsSUFBSSxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDOUIsQ0FBQztDQUNsQixDQUFBOztBQUpZLGFBQWE7SUFIekIsVUFBVSxDQUFDO1FBQ1YsVUFBVSxFQUFFLE1BQU07S0FDbkIsQ0FBQztHQUNXLGFBQWEsQ0FJekI7U0FKWSxhQUFhIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QgfSBmcm9tICdyeGpzJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIExvYWRlclNlcnZpY2Uge1xyXG5cclxuICBwdWJsaWMgaXNMb2FkaW5nID0gbmV3IEJlaGF2aW9yU3ViamVjdChmYWxzZSk7XHJcbiAgY29uc3RydWN0b3IoKSB7IH1cclxufVxyXG4iXX0=

package/esm2015/lib/services/log.service.js

@@ -0,0 +1,76 @@
+import { __decorate } from "tslib";
+import { Core } from 'tin-core';
+import { Injectable } from "@angular/core";
+import { LogLevel } from '../classes/Classes';
+import * as i0 from "@angular/core";
+let LogService = class LogService {
+    constructor() {
+        this.level = LogLevel.All;
+        this.logToConsole = true;
+        this.logToApi = false;
+    }
+    debug(msg, ...optionalParams) {
+        this.writeToLog(msg, LogLevel.Debug, optionalParams);
+    }
+    info(msg, ...optionalParams) {
+        this.writeToLog(msg, LogLevel.Info, optionalParams);
+    }
+    warn(msg, ...optionalParams) {
+        this.writeToLog(msg, LogLevel.Warn, optionalParams);
+    }
+    error(msg, ...optionalParams) {
+        this.writeToLog(msg, LogLevel.Error, optionalParams);
+    }
+    fatal(msg, ...optionalParams) {
+        this.writeToLog(msg, LogLevel.Fatal, optionalParams);
+    }
+    log(msg, ...optionalParams) {
+        this.writeToLog(msg, LogLevel.All, optionalParams);
+    }
+    writeToLog(msg, level, params) {
+        if (this.shouldLog(level)) {
+            // Build log string
+            let value = Core.getFormatedDate(Date(), false).replace("T", " ");
+            // value += " - Type: " + LogLevel[this.level];
+            value += " - Message: " + msg;
+            if (params.length) {
+                value += " - Extra Info: " + this.formatParams(params);
+            }
+            // Log the value
+            if (this.logToConsole) {
+                console.log(value);
+            }
+            if (this.logToApi) {
+                //Call API post
+            }
+        }
+    }
+    formatParams(params) {
+        let ret = params.join(",");
+        // Is there at least one object in the array?
+        if (params.some((p) => typeof p == "object")) {
+            ret = "";
+            // Build comma-delimited string
+            for (let item of params) {
+                ret += JSON.stringify(item) + ",";
+            }
+        }
+        return ret;
+    }
+    shouldLog(level) {
+        let ret = false;
+        if ((level >= this.level && level !== LogLevel.Off) ||
+            this.level === LogLevel.All) {
+            ret = true;
+        }
+        return ret;
+    }
+};
+LogService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LogService_Factory() { return new LogService(); }, token: LogService, providedIn: "root" });
+LogService = __decorate([
+    Injectable({
+        providedIn: "root",
+    })
+], LogService);
+export { LogService };
+//# sourceMappingURL=data:application/json;base64,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