tin-spa 2.13.15 → 9.1.0

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

@@ -0,0 +1,142 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { Role } from '../classes/Classes';
+import { Constants } from '../classes/TinCore';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./storage.service";
+import * as i3 from "./http.service";
+import * as i4 from "./message.service";
+import * as i5 from "./log.service";
+export class AuthService {
+    constructor(_route, storage, router, httpService, messageService, logService) {
+        this._route = _route;
+        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);
+            let url = new URL(window.location.href);
+            let path = url.hash.replace("#/", "");
+            this.router.navigate(["login"], {
+                relativeTo: this._route,
+                queryParams: { redirectTo: path },
+                queryParamsHandling: 'merge',
+                skipLocationChange: false
+            });
+            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);
+            });
+            this.storage.get(Constants.AUTH_NAME).then((resp) => {
+                this.updateLoggedUserFullName(resp);
+            });
+            this.storage.get(Constants.AUTH_ROLES).then((resp) => {
+                let ret = JSON.parse(resp);
+                this.UpdateRole(ret);
+            });
+            this.storage.get(Constants.AUTH_TOKEN).then((resp) => {
+                this.UpdateToken(resp);
+            });
+            this.storage.get(Constants.AUTH_TOKEN_EXPIRE).then((resp) => {
+                this.UpdateTokenExpire(resp);
+                this.isValidToken();
+            });
+            return true;
+        }
+    }
+}
+AuthService.ɵfac = function AuthService_Factory(t) { return new (t || AuthService)(i0.ɵɵinject(i1.ActivatedRoute), i0.ɵɵinject(i2.StorageService), i0.ɵɵinject(i1.Router), i0.ɵɵinject(i3.HttpService), i0.ɵɵinject(i4.MessageService), i0.ɵɵinject(i5.LogService)); };
+AuthService.ɵprov = i0.ɵɵdefineInjectable({ token: AuthService, factory: AuthService.ɵfac, providedIn: 'root' });
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(AuthService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.ActivatedRoute }, { type: i2.StorageService }, { type: i1.Router }, { type: i3.HttpService }, { type: i4.MessageService }, { type: i5.LogService }]; }, null); })();
+//# 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\nimport { Injectable } from '@angular/core';\r\nimport { Router, CanActivate, ActivatedRoute } 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\nimport { HttpService } from './http.service';\r\nimport { Constants } from '../classes/TinCore';\r\nimport { conditionallyCreateMapObjectLiteral } from '@angular/compiler/src/render3/view/util';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\n\r\nexport class AuthService implements CanActivate {\r\n\r\n  constructor(private _route: ActivatedRoute, private storage: StorageService, public router: Router, private httpService: HttpService, private messageService: MessageService, private logService: LogService) { }\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    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    let tokenExpire: Date = new Date(this.tokenExpireSource.value);\r\n    let nowDate: Date = new Date();\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  canActivate() {\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\r\n      let url = new URL(window.location.href);\r\n      let path = url.hash.replace(\"#/\",\"\");\r\n\r\n\r\n      this.router.navigate([\"login\"], {\r\n        relativeTo: this._route,\r\n        queryParams: {redirectTo: path},\r\n        queryParamsHandling: 'merge',\r\n        skipLocationChange: false\r\n      });\r\n\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      });\r\n\r\n      this.storage.get(Constants.AUTH_NAME).then((resp: any) => {\r\n        this.updateLoggedUserFullName(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      });\r\n\r\n      this.storage.get(Constants.AUTH_TOKEN).then((resp: any) => {\r\n        this.UpdateToken(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      return true;\r\n    }\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,111 @@
+import { Injectable } from '@angular/core';
+import { AppConfig, CapItem } from '../classes/Classes';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./http.service";
+export class DataServiceLib {
+    constructor(httpService) {
+        this.httpService = httpService;
+        this.appConfig = new AppConfig();
+        this.appConfigSource = new BehaviorSubject(this.appConfig);
+        this.appConfigObserv = this.appConfigSource.asObservable();
+        // caps: CapItem[];
+        this.capHome = new CapItem;
+        this.capAdmin = new CapItem;
+        this.capUsers = new CapItem;
+        this.capRoles = new CapItem;
+        this.capLogs = new CapItem;
+        this.capSettings = new CapItem;
+        this.tmpProfileuserName = "";
+        this.appConfig.appName = "App-Name";
+        this.appConfig.logo = "./assets/logo.png";
+        this.appConfig.ADAuth = true;
+        this.appConfig.capItems = [this.capAdmin, this.capHome];
+        this.capHome.name = "cap1";
+        this.capHome.display = "Home";
+        this.capHome.link = "home";
+        this.capAdmin.name = "cap2";
+        this.capAdmin.display = "Admin";
+        this.capAdmin.capSubItems = [this.capUsers, this.capRoles, this.capLogs, this.capSettings];
+        this.capUsers.name = "cap3";
+        this.capUsers.display = "Users";
+        this.capUsers.link = "home/admin/users";
+        this.capRoles.name = "cap4";
+        this.capRoles.display = "Roles";
+        this.capRoles.link = "home/admin/roles";
+        this.capLogs.name = "cap5";
+        this.capLogs.display = "Logs";
+        this.capLogs.link = "home/admin/logs";
+        this.capSettings.name = "cap6";
+        this.capSettings.display = "Settings";
+        this.capSettings.link = "home/admin/settings";
+    }
+    UpdateAppConfig(config) {
+        this.appConfigSource.next(config);
+        this.appConfig = config;
+    }
+    //Users
+    GetUser() {
+        return this.httpService.Get("User/all/x");
+    }
+    RegisterAccount(u) {
+        return this.httpService.Post("User/register", u);
+    }
+    GetUserByID(val) {
+        return this.httpService.Get(`User/id/${val}`);
+    }
+    UpdateUser(profile) {
+        return this.httpService.Post("User/edit", profile);
+    }
+    UnlockUser(user) {
+        return this.httpService.Post("User/unlock", user);
+    }
+    LockUser(user) {
+        return this.httpService.Post("User/lock", user);
+    }
+    DeleteUser(user) {
+        return this.httpService.Post("User/delete", user);
+    }
+    Login(u) {
+        return this.httpService.Post("User/login", u);
+    }
+    ChangePassword(u) {
+        return this.httpService.Post("User/changepassword-self", u);
+    }
+    ChangePasswordAdmin(u) {
+        return this.httpService.Post("User/changepassword-admin", u);
+    }
+    SelfReset(u) {
+        return this.httpService.Post("Basic/SelfReset", u);
+    }
+    //Roles
+    PostRole(role, action) {
+        return this.httpService.Post(`Role?action=${action}`, role);
+    }
+    PutRole(role) {
+        return this.httpService.Put("Role", role);
+    }
+    GetRole(by, val) {
+        return this.httpService.Get("Role/all/x");
+    }
+    //Logs
+    GetLog(by, val) {
+        return this.httpService.Get("Log/all/x");
+    }
+    //Settings
+    GetSetting(by, val) {
+        return this.httpService.Get("Setting/all/x");
+    }
+    UpdateSetting(setting, action) {
+        return this.httpService.Post(`Setting?action=${action}`, setting);
+    }
+}
+DataServiceLib.ɵfac = function DataServiceLib_Factory(t) { return new (t || DataServiceLib)(i0.ɵɵinject(i1.HttpService)); };
+DataServiceLib.ɵprov = i0.ɵɵdefineInjectable({ token: DataServiceLib, factory: DataServiceLib.ɵfac, providedIn: 'root' });
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(DataServiceLib, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data.service.js","sourceRoot":"ng://tin-spa/","sources":["lib/services/data.service.ts"],"names":[],"mappings":"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","sourcesContent":["\r\nimport { Injectable } from '@angular/core';\r\nimport { AppConfig, CapItem, User } from '../classes/Classes';\r\nimport { BehaviorSubject, Observable } from 'rxjs';\r\nimport { HttpService } from './http.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class DataServiceLib {\r\n\r\n  constructor(private httpService: HttpService) {\r\n\r\n    this.appConfig.appName = \"App-Name\";\r\n    this.appConfig.logo = \"./assets/logo.png\"\r\n    this.appConfig.ADAuth = true;\r\n    this.appConfig.capItems = [this.capAdmin, this.capHome];\r\n\r\n\r\n    this.capHome.name = \"cap1\";\r\n    this.capHome.display = \"Home\";\r\n    this.capHome.link = \"home\";\r\n\r\n    this.capAdmin.name = \"cap2\";\r\n    this.capAdmin.display = \"Admin\";\r\n    this.capAdmin.capSubItems = [this.capUsers, this.capRoles, this.capLogs, this.capSettings];\r\n\r\n    this.capUsers.name = \"cap3\";\r\n    this.capUsers.display = \"Users\";\r\n    this.capUsers.link = \"home/admin/users\";\r\n\r\n    this.capRoles.name = \"cap4\"\r\n    this.capRoles.display = \"Roles\";\r\n    this.capRoles.link = \"home/admin/roles\";\r\n\r\n    this.capLogs.name = \"cap5\"\r\n    this.capLogs.display = \"Logs\";\r\n    this.capLogs.link = \"home/admin/logs\";\r\n\r\n    this.capSettings.name = \"cap6\"\r\n    this.capSettings.display = \"Settings\";\r\n    this.capSettings.link = \"home/admin/settings\";\r\n  }\r\n\r\n\r\n  appConfig = new AppConfig();\r\n  private appConfigSource = new BehaviorSubject(this.appConfig);\r\n  public appConfigObserv = this.appConfigSource.asObservable();\r\n  UpdateAppConfig(config: AppConfig) {\r\n    this.appConfigSource.next(config);\r\n    this.appConfig = config;\r\n  }\r\n\r\n  // caps: CapItem[];\r\n  capHome = new CapItem;\r\n  capAdmin = new CapItem;\r\n  capUsers = new CapItem;\r\n  capRoles = new CapItem;\r\n  capLogs = new CapItem;\r\n  capSettings = new CapItem;\r\n\r\n\r\n  public tmpProfileuserName = \"\";\r\n\r\n\r\n  //Users\r\n  public GetUser() {\r\n    return this.httpService.Get(\"User/all/x\");\r\n  }\r\n\r\n  public RegisterAccount(u) {\r\n    return this.httpService.Post(\"User/register\", u);\r\n  }\r\n\r\n  public GetUserByID(val: string) {\r\n    return this.httpService.Get(`User/id/${val}`);\r\n  }\r\n\r\n  public UpdateUser(profile) {\r\n    return this.httpService.Post(\"User/edit\", profile);\r\n  }\r\n\r\n  public UnlockUser(user) {\r\n    return this.httpService.Post(\"User/unlock\", user);\r\n  }\r\n\r\n  public LockUser(user) {\r\n    return this.httpService.Post(\"User/lock\", user);\r\n  }\r\n\r\n  public DeleteUser(user) {\r\n    return this.httpService.Post(\"User/delete\", user);\r\n  }\r\n\r\n  public Login(u: User) {\r\n    return this.httpService.Post(\"User/login\", u);\r\n  }\r\n\r\n  public ChangePassword(u) {\r\n    return this.httpService.Post(\"User/changepassword-self\", u);\r\n  }\r\n\r\n  public ChangePasswordAdmin(u) {\r\n    return this.httpService.Post(\"User/changepassword-admin\", u);\r\n  }\r\n\r\n  public SelfReset(u: User): Observable<any> {\r\n    return this.httpService.Post(\"Basic/SelfReset\", u);\r\n  }\r\n\r\n\r\n  //Roles\r\n\r\n  public PostRole(role, action: string) {\r\n    return this.httpService.Post(`Role?action=${action}`, role);\r\n  }\r\n\r\n  public PutRole(role) {\r\n    return this.httpService.Put(\"Role\", role);\r\n  }\r\n\r\n  public GetRole(by: string, val: string) {\r\n    return this.httpService.Get(\"Role/all/x\");\r\n  }\r\n\r\n\r\n\r\n  //Logs\r\n  public GetLog(by: string, val: string) {\r\n    return this.httpService.Get(\"Log/all/x\");\r\n  }\r\n\r\n\r\n  //Settings\r\n  public GetSetting(by: string, val: string) {\r\n    return this.httpService.Get(\"Setting/all/x\");\r\n  }\r\n\r\n  public UpdateSetting(setting, action: string) {\r\n    return this.httpService.Post(`Setting?action=${action}`, setting);\r\n  }\r\n\r\n}\r\n"]}

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

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import * as FileSaver from 'file-saver';
+import * as XLSX from 'xlsx';
+import * as i0 from "@angular/core";
+export 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.ɵfac = function ExportService_Factory(t) { return new (t || ExportService)(); };
+ExportService.ɵprov = i0.ɵɵdefineInjectable({ token: ExportService, factory: ExportService.ɵfac, providedIn: 'root' });
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(ExportService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,79 @@
+import { Injectable } from "@angular/core";
+import { HttpHeaders, } from "@angular/common/http";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/router";
+export class HttpService {
+    constructor(httpClient, router) {
+        this.httpClient = httpClient;
+        this.router = router;
+        //----Set apiUrl from the data service of the project---//
+        this.apiUrl = "https://api.solinc.co.zw/"; //default
+        this.httpOptions_Legacy = {
+            headers: new HttpHeaders({
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                Authorization: "Basic " + btoa("emptyUser:emptyToken"),
+            }),
+            resposeType: "json",
+        };
+        this.httpOptions_Files = {
+            headers: new HttpHeaders({
+                Authorization: "Basic " + btoa("tnyagato:j5Toszfr@ys"),
+            }),
+            resposeType: "json",
+        };
+    }
+    //POST
+    Post(service, data) {
+        return this.httpClient.post(this.apiUrl + service, data, this.httpOptions_Legacy);
+    }
+    //PUT
+    Put(service, data) {
+        return this.httpClient.put(this.apiUrl + service, data, this.httpOptions_Legacy);
+    }
+    //POST RAW
+    Post_Raw(url, data) {
+        return this.httpClient.post(url, data, this.httpOptions_Legacy);
+    }
+    //POST with file
+    Post_WithFile(service, data, file) {
+        let formData = new FormData();
+        if (file) {
+            formData.append("uploadFile", file, file.name);
+        }
+        formData.append("data", JSON.stringify(data));
+        return this.httpClient.post(this.apiUrl + service, formData, this.httpOptions_Files);
+    }
+    //  //POST with files
+    Post_FormData(service, formData) {
+        return this.httpClient.post(this.apiUrl + service, formData, this.httpOptions_Files);
+    }
+    //GET
+    Get(service) {
+        return this.httpClient.get(this.apiUrl + service, this.httpOptions_Legacy);
+    }
+    //Get RAW
+    Get_Raw(url) {
+        return this.httpClient.get(url, this.httpOptions_Legacy);
+    }
+    //ERROR
+    Error(error) {
+        if (error.statusText == "Unauthorized") {
+            this.router.navigate(["login"]);
+            return "Unauthorized";
+        }
+        else {
+            return "Connection failed";
+        }
+    }
+}
+HttpService.ɵfac = function HttpService_Factory(t) { return new (t || HttpService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.Router)); };
+HttpService.ɵprov = i0.ɵɵdefineInjectable({ token: HttpService, factory: HttpService.ɵfac, providedIn: "root" });
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(HttpService, [{
+        type: Injectable,
+        args: [{
+                providedIn: "root",
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.Router }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,77 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./loader.service";
+import * as i2 from "./message.service";
+import * as i3 from "./auth.service";
+import * as i4 from "@angular/router";
+import * as i5 from "./log.service";
+export 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: "Bearer " + this.authService.tokenSource.value
+            }
+        });
+        this.requests.push(requestClone);
+        if (this.requests.length > 1) {
+            this.logService.info("Multiple connections detected > " + this.requests.length);
+        }
+        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);
+                }
+            }, (error) => {
+                this.removeRequest(requestClone);
+                observer.error(error);
+                if (error.status === 401) {
+                    this.router.navigate(["login"]);
+                    this.messageService.toast('Unauthorised: Please login again');
+                }
+                else if (error.status === 500) {
+                    console.log(error.error);
+                    this.messageService.toast('System Error');
+                }
+                else if (error.statusText == 'Unknown Error') {
+                    this.messageService.toast('Connection Error');
+                }
+                else {
+                    this.messageService.toast('Error: ' + error.statusText);
+                }
+            }, () => {
+                this.removeRequest(requestClone);
+                observer.complete();
+            });
+            // remove request from queue when cancelled
+            return () => {
+                this.removeRequest(requestClone);
+                subscription.unsubscribe();
+            };
+        });
+    }
+}
+LoaderInterceptor.ɵfac = function LoaderInterceptor_Factory(t) { return new (t || LoaderInterceptor)(i0.ɵɵinject(i1.LoaderService), i0.ɵɵinject(i2.MessageService), i0.ɵɵinject(i3.AuthService), i0.ɵɵinject(i4.Router), i0.ɵɵinject(i5.LogService)); };
+LoaderInterceptor.ɵprov = i0.ɵɵdefineInjectable({ token: LoaderInterceptor, factory: LoaderInterceptor.ɵfac });
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(LoaderInterceptor, [{
+        type: Injectable
+    }], function () { return [{ type: i1.LoaderService }, { type: i2.MessageService }, { type: i3.AuthService }, { type: i4.Router }, { type: i5.LogService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,76 @@
+import { Injectable } from "@angular/core";
+import { LogLevel } from '../classes/Classes';
+import { Core } from '../classes/TinCore';
+import * as i0 from "@angular/core";
+export 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.ɵfac = function LogService_Factory(t) { return new (t || LogService)(); };
+LogService.ɵprov = i0.ɵɵdefineInjectable({ token: LogService, factory: LogService.ɵfac, providedIn: "root" });
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(LogService, [{
+        type: Injectable,
+        args: [{
+                providedIn: "root",
+            }]
+    }], function () { return []; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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