taxtank-core 0.0.1 → 0.1.1

package/src/lib/services/chart-accounts/chart-accounts.service.ts

@@ -0,0 +1,101 @@
+import { Inject, Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, ReplaySubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ChartAccountsCategoryEnum } from '../../db/Enums/chart-accounts-category.enum';
+import { ChartAccounts as ChartAccountBase } from '../../db/Models/chart-accounts';
+import { plainToClass } from 'class-transformer';
+import { ChartAccounts } from '../../models/chart-accounts/chart-accounts';
+import { ChartAccountsHeading } from '../../models/chart-accounts/chart-accounts-heading';
+import { CHART_ACCOUNTS_CATEGORIES } from '../../models/chart-accounts/chart-accounts-categories.const';
+
+/**
+ * Chart accounts service
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ChartAccountsService {
+  _chartAccounts: ChartAccounts[];
+  chartAccountsSubject: ReplaySubject<ChartAccounts[]> = new ReplaySubject<ChartAccounts[]>(1);
+
+  constructor(
+    private http: HttpClient,
+    @Inject('environment') private environment: any
+  ) {
+  }
+
+  /**
+   * get all parent and child chart accounts and group it
+   */
+  getChartAccounts(): Observable<ChartAccounts[]> {
+    if (!this._chartAccounts) {
+      this._chartAccounts = [];
+      this.http.get(`${this.environment.apiV2}/chart-accounts`)
+        .pipe(
+          map((response: ChartAccountBase[]) => {
+            return response.map((item: ChartAccountBase) => plainToClass(ChartAccounts, item));
+          })
+        )
+        .subscribe((chartAccounts: ChartAccounts[]) => {
+          this._chartAccounts = chartAccounts;
+          this.chartAccountsSubject.next(this._chartAccounts);
+        });
+    }
+
+    return this.chartAccountsSubject.asObservable();
+  }
+
+  /**
+   * Get list of chart accounts heading
+   * @param categories
+   */
+  getChartAccountsHeadings(categories: ChartAccountsCategoryEnum[] = CHART_ACCOUNTS_CATEGORIES.all): Observable<ChartAccountsHeading[]> {
+    return this.getChartAccounts()
+      .pipe(
+        map((chartAccounts: ChartAccounts[]) => {
+          const filteredChartAccounts: ChartAccounts[] = chartAccounts.filter((ca: ChartAccounts) => categories.includes(ca.category));
+          const headings: ChartAccountsHeading[] = [];
+
+          filteredChartAccounts.forEach((ca: ChartAccounts) => {
+            let heading: ChartAccountsHeading = headings.find((h: ChartAccountsHeading) => h.id === ca.heading?.id);
+
+            if (!heading) {
+              heading = plainToClass(ChartAccountsHeading, ca.heading);
+              heading.chartAccounts = [];
+              headings.push(heading);
+            }
+
+            heading.chartAccounts.push(ca);
+          });
+          return headings;
+        })
+      );
+  }
+
+  /**
+   * Get heading of chart accounts by it Id
+   * @param id
+   */
+  getHeadingByChartAccountsId(id: number): Observable<ChartAccountsHeading> {
+    return this.getChartAccountsById(id)
+      .pipe(
+        map((chartAccounts: ChartAccounts) => {
+          return chartAccounts.heading;
+        })
+      );
+  }
+
+  /**
+   * Get chart accounts by Id
+   * @param id
+   */
+  getChartAccountsById(id: number): Observable<ChartAccounts> {
+    return this.getChartAccounts()
+      .pipe(
+        map((chartAccountsList: ChartAccounts[]) => {
+          return chartAccountsList.find((chartAccounts: ChartAccounts) => chartAccounts.id === id);
+        })
+      );
+  }
+}

package/src/lib/services/chat/chat.service.spec.ts

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

package/src/lib/services/chat/chat.service.ts

@@ -0,0 +1,79 @@
+import { Inject, Injectable } from '@angular/core';
+import { Chat as ChatBase } from '../../db/Models/chat';
+import { HttpClient } from '@angular/common/http';
+import { SseService } from '../event/sse.service';
+import { BaseRestService } from '../base-rest.service';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import cloneDeep from 'lodash/cloneDeep';
+import { replace } from '../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { Chat } from '../../models/chat/chat';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+
+/**
+ * Service for work with chats
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ChatService extends BaseRestService<ChatBase, Chat> implements IEventListener {
+  modelClass: typeof Chat = Chat;
+  url: string = 'chats';
+  isHydra: boolean = true;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any,
+    private sseService: SseService
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * SSE and Event Dispatcher Services listeners
+   */
+  listenEvents(): void {
+    this.listenChats();
+  }
+
+  /**
+   * Listen chats events
+   */
+  listenChats(): void {
+    this.sseService.on(`chats`).subscribe((chatBase: ChatBase): void => {
+      let cache: Chat[] = cloneDeep(this.cache);
+      // chat instance from event
+      const eventChat: Chat = plainToClass(Chat, chatBase);
+      // chat instance from cache
+      const cachedChat: Chat = cache.find((chat: Chat): boolean => chat.id === eventChat.id);
+
+      switch (true) {
+        // add new chat
+        case (!cachedChat):
+          cache.push(eventChat);
+          break;
+
+        // remove deactivated chat
+        case !eventChat.isActive():
+          cache = cache.filter((chat: Chat): boolean => chat.id !== eventChat.id);
+          break;
+
+        // update chat with new firm (reassign)
+        case eventChat.employee.id !== cachedChat.employee.id:
+          replace(cache, eventChat);
+          break;
+
+        // @TODO typing works bad with mat-tabs on user-area. Need to refactor typing functionality
+        // update cache with typing user
+        // default:
+          // cachedChat.typingUsers.push(new User(eventChat.typingUser));
+          // replace(cache, _.clone(cachedChat));
+      }
+
+      this.cache = cache;
+      this.updateCache();
+    });
+  }
+}

package/src/lib/services/chat/message-document.service.spec.ts

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

package/src/lib/services/chat/message-document.service.ts

@@ -0,0 +1,133 @@
+import { Inject, Injectable } from '@angular/core';
+import { MessageDocument as MessageDocumentBase } from '../../db/Models/message-document';
+import { combineLatest, Observable, ReplaySubject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import _ from 'lodash';
+import { plainToClass } from 'class-transformer';
+import { MessageDocument } from '../../models/chat/message-document';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { Message } from '../../models/chat/message';
+
+// @TODO improve base rest service and extend it
+/**
+ * Service for work with Message Documents
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class MessageDocumentService implements IEventListener {
+  url: string = 'message-documents';
+  cache: Readonly<Array<Readonly<MessageDocument>>>;
+  cacheSubject: ReplaySubject<Readonly<Array<Readonly<MessageDocument>>>> = new ReplaySubject<Readonly<Array<Readonly<MessageDocument>>>>();
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    this.listenEvents();
+  }
+
+  /**
+   * SSE and Event Dispatcher Services listeners
+   */
+  listenEvents(): void {
+    this.listenMessages();
+  }
+
+  /**
+   * listen new messages event to update documents cache
+   */
+  listenMessages(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.MESSAGE_CREATED).subscribe((message: Message): void => {
+      if (message.documents.length) {
+        const cache: MessageDocument[] = _.clone(this.cache);
+        const documentsIds: number[] = this.cache.map((d: MessageDocument): number => d.id);
+        message.documents.forEach((d: MessageDocument): void => {
+          d.chat = message.chat;
+          if (!documentsIds.includes(d.id)) {
+            cache.push(...message.documents);
+          }
+        });
+        this.cache = cache;
+        this.cacheSubject.next(this.cache);
+      }
+    });
+  }
+
+  /**
+   * get list of message documents
+   */
+  get(): Observable<Readonly<MessageDocument[]>> {
+    if (!this.cache) {
+      this.http.get(`${this.environment.apiV2}/${this.url}`)
+        .pipe(
+          map((response: object): MessageDocument[] => {
+            return response['hydra:member'].map((docBase: MessageDocumentBase): MessageDocument => plainToClass(MessageDocument, docBase));
+          })
+        )
+        .subscribe((documents: MessageDocument[]): void => {
+          this.cache = documents;
+          this.cacheSubject.next(this.cache);
+        });
+    }
+
+    return this.cacheSubject.asObservable();
+  }
+
+  /**
+   * Upload file to chat
+   * @param chatId
+   * @param file
+   */
+  add(chatId: number, file: File): Observable<MessageDocument> {
+    const formData: FormData = new FormData();
+    formData.append('file', file);
+    formData.append('chat', chatId.toString());
+
+    return this.http.post(`${this.environment.apiV2}/${this.url}`, formData)
+      .pipe(
+        map((documentBase: MessageDocumentBase): MessageDocument => {
+          const document: MessageDocument = plainToClass(MessageDocument, documentBase);
+          const cache: MessageDocument[] = _.clone(this.cache);
+          cache.push(document);
+          this.cache = cache;
+          this.cacheSubject.next(this.cache);
+          return document;
+        })
+      );
+  }
+
+  /**
+   * Upload multiple files to chat
+   * @param chatId
+   * @param files
+   */
+  addBatch(chatId: number, files: File[]): Observable<MessageDocument[]> {
+    return combineLatest(
+      files.map((file: File): Observable<MessageDocument> => this.add(chatId, file))
+    ).pipe(
+      map((docsBase: MessageDocumentBase[]): MessageDocument[] => {
+        return docsBase.map((docBase: MessageDocumentBase): MessageDocument => plainToClass(MessageDocument, docBase));
+      })
+    );
+  }
+
+  /**
+   * Delete uploaded chat document
+   * @param chatId
+   * @param documentId
+   */
+  delete(chatId: number, documentId: number): Observable<void> {
+    return this.http.delete(`${this.environment.apiV2}/${this.url}/${documentId}`)
+      .pipe(
+        map((): void => {
+          this.cache = this.cache.filter((document: MessageDocument): boolean => document.id !== documentId);
+          this.cacheSubject.next(this.cache);
+        })
+      );
+  }
+}

package/src/lib/services/chat/message.service.spec.ts

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

package/src/lib/services/chat/message.service.ts

@@ -0,0 +1,61 @@
+import { Inject, Injectable } from '@angular/core';
+import { Message as MessageBase } from '../../db/Models/message';
+import { IEventListener } from '../../interfaces/event-listener.interface';
+import { HttpClient } from '@angular/common/http';
+import _ from 'lodash';
+import { replace } from '../../functions/array';
+import { plainToClass } from 'class-transformer';
+import { Message } from '../../models/chat/message';
+import { BaseRestService } from '../base-rest.service';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { SseService } from '../event/sse.service';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+
+/**
+ * Service for work with messages
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class MessageService extends BaseRestService<MessageBase, Message> implements IEventListener {
+  modelClass: typeof Message = Message;
+  url: string = 'messages';
+  isHydra: boolean = true;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any,
+    private sseService: SseService
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * SSE and Event Dispatcher Services listeners
+   */
+  listenEvents(): void {
+    this.listenMessages();
+  }
+
+  /**
+   * subscribe to new chat messages
+   */
+  private listenMessages(): void {
+    this.sseService.on(`messages`).subscribe((messageBase: MessageBase): void => {
+      const message: Message = plainToClass(Message, messageBase);
+      const cache: Message[] = _.clone(this.cache);
+      // update existing message if read and add new message if not read
+      if (message.isRead()) {
+        replace(cache, message);
+      } else {
+        cache.push(message);
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.MESSAGE_CREATED, message));
+      }
+      this.cache = cache;
+      this.cacheSubject.next(this.cache);
+    });
+  }
+}

package/src/lib/services/client/client-invite.service.spec.ts

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

package/src/lib/services/client/client-invite.service.ts

@@ -0,0 +1,111 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ClientInvite as ClientInviteBase } from '../../db/Models/client-invite';
+import { map } from 'rxjs/operators';
+import { replace } from '../../functions/array';
+import _ from 'lodash';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { ClientInvite } from '../../models/client/client-invite';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+import { AppEvent } from '../../models/event/app-event';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ClientInviteService extends BaseRestService<ClientInviteBase, ClientInvite> {
+  url: string = 'clients/invites';
+  modelClass: typeof ClientInvite = ClientInvite;
+
+  /**
+   * Import employees for firm from CSV file
+   * @param file
+   */
+  import(file: File): Observable<ClientInvite[]> {
+    const formData: FormData = new FormData();
+    formData.append('file', file);
+
+    return this.http.post(`${this.environment.apiV2}/${this.url}/import`, formData)
+      .pipe(
+        map((clientInvite: ClientInvite[]) => {
+          return clientInvite;
+        })
+      );
+  }
+
+  /**
+   * Accept client invitation from firm to user
+   * @param invite
+   */
+  accept(invite: ClientInvite): Observable<any> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/accept`, null)
+      .pipe(
+        map((): void => {
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_INVITE_ACCEPTED, invite));
+          // set cache without accepted invite
+          this.cache = this.cache.filter((clientInvite: ClientInvite) => invite.id !== clientInvite.id);
+          this.updateCache();
+        })
+      );
+  }
+
+  /**
+   * Reject client invitation from firm to user
+   * @param invite
+   */
+  reject(invite: ClientInvite): Observable<ClientInvite> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/reject`, null)
+      .pipe(
+        map((rejectedInvite: ClientInviteBase): ClientInvite => {
+          const updatedInvite: ClientInvite = plainToClass(ClientInvite, rejectedInvite);
+          // avoid cache changes
+          // @TODO make cache readonly
+          const tempCache: ClientInvite[] = _.cloneDeep(this.cache);
+          replace(tempCache, plainToClass(ClientInvite, updatedInvite));
+          this.cache = tempCache;
+          this.updateCache();
+          return updatedInvite;
+        })
+      );
+  }
+
+  /**
+   * Resend invitation from firm to client
+   * @param invite
+   */
+  resend(invite: ClientInvite): Observable<ClientInvite> {
+    return this.http.post(`${this.environment.apiV2}/${this.url}/${invite.id}/resend`, null)
+      .pipe(
+        map((rejectedInvite: ClientInviteBase): ClientInvite => {
+          const updatedInvite: ClientInvite = plainToClass(ClientInvite, rejectedInvite);
+          // avoid cache changes
+          // @TODO make cache readonly
+          const tempCache: ClientInvite[] = _.cloneDeep(this.cache);
+          replace(tempCache, plainToClass(ClientInvite, updatedInvite));
+          this.cache = tempCache;
+          this.updateCache();
+          return updatedInvite;
+        })
+      );
+  }
+
+  /**
+   * Send invitation from client to firm
+   * @param invite
+   */
+  inviteFirmByUser(invite: ClientInvite): Observable<ClientInvite> {
+    return this.http.post(`${this.environment.apiV2}/firms/invite`, invite)
+      .pipe(
+        map((inviteBase: ClientInviteBase): ClientInvite => {
+          const newInvite: ClientInvite = plainToClass(ClientInvite, inviteBase);
+          // avoid cache changes
+          // @TODO make cache readonly
+          const tempCache: ClientInvite[] = _.cloneDeep(this.cache);
+          tempCache.push(newInvite);
+          this.cache = tempCache;
+          this.updateCache();
+          return newInvite;
+        })
+      );
+  }
+}

package/src/lib/services/client/client-movement.service.spec.ts

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

package/src/lib/services/client/client-movement.service.ts

@@ -0,0 +1,114 @@
+import { Inject, Injectable } from '@angular/core';
+import { ClientMovement as ClientMovementBase } from '../../db/Models/client-movement';
+import { forkJoin, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ClientMovementCollection } from '../../collections/client-movement.collection';
+import { FirmTypeEnum } from '../../db/Enums/firm-type.enum';
+import { HttpClient } from '@angular/common/http';
+import { plainToClass } from 'class-transformer';
+import { BaseRestService } from '../base-rest.service';
+import { ClientMovement } from '../../models/client/client-movement';
+import { EventDispatcherService } from '../event/event-dispatcher.service';
+import { AppEvent } from '../../models/event/app-event';
+import { AppEventTypeEnum } from '../../models/event/app-event-type.enum';
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ClientMovementService extends BaseRestService<ClientMovementBase, ClientMovement> {
+  modelClass: typeof ClientMovement = ClientMovement;
+  url: string = 'client-movements';
+  isHydra: boolean = true;
+
+  constructor(
+    protected http: HttpClient,
+    protected eventDispatcherService: EventDispatcherService,
+    @Inject('environment') protected environment: any
+  ) {
+    super(http, eventDispatcherService, environment);
+    this.listenEvents();
+  }
+
+  /**
+   * @TODO BaseRestService should return collection
+   */
+  getAll(): Observable<ClientMovementCollection> {
+    return this.get().pipe(
+      map((clientMovements: ClientMovement[]) => {
+        return new ClientMovementCollection(clientMovements);
+      })
+    );
+  }
+
+  getActive(): Observable<ClientMovementCollection> {
+    return this.getAll().pipe(
+      map((clientMovements: ClientMovementCollection): ClientMovementCollection => {
+        return clientMovements.active;
+      })
+    );
+  }
+
+  getActiveByFirmType(type: FirmTypeEnum): Observable<ClientMovementCollection> {
+    return this.getActive().pipe(
+      map((clientMovements: ClientMovementCollection): ClientMovementCollection => {
+        return clientMovements.getByFirmType(type);
+      })
+    );
+  }
+
+  update(movement: ClientMovement): Observable<ClientMovement> {
+    // extend base 'add' method and pass into it movement without id
+    return super.add(plainToClass(ClientMovement, Object.assign({}, movement, {id: null}))).pipe(
+      map((updatedMovement: ClientMovement) => {
+        // remove provided movement from cache
+        this.cache = this.cache.filter((item: ClientMovement) => item.id !== movement.id);
+        this.updateCache();
+
+        this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_TRANSFER_TO_OTHER_EMPLOYEE, [updatedMovement.client]));
+
+        return updatedMovement;
+      })
+    );
+  }
+
+  updateBatch(clientMovements: ClientMovement[]): Observable<ClientMovement[]> {
+    const batch: Observable<ClientMovement>[] = clientMovements.map((clientMovement: ClientMovement) => this.update(clientMovement));
+    return forkJoin(batch);
+  }
+
+  /**
+   * Reject current firm
+   */
+  close(clientMovement: ClientMovement): Observable<void> {
+    clientMovement.dateTo = new Date();
+    return this.http.put(`${this.environment.apiV2}/client-movements/${clientMovement.id}/close`, clientMovement)
+      .pipe(
+        map((): void => {
+          this.eventDispatcherService.dispatch(new AppEvent(AppEventTypeEnum.CLIENT_MOVEMENT_CLOSED, null));
+          this.cache = this.cache.filter((movement: ClientMovement): boolean => movement.id !== clientMovement.id);
+          this.updateCache();
+        })
+      );
+  }
+
+  /**
+   * Listen Event Dispatcher service
+   */
+  listenEvents(): void {
+    this.listenClientInvites();
+  }
+
+  /**
+   * Listen to EventDispatcherService event related to clients invitations
+   */
+  private listenClientInvites(): void {
+    this.eventDispatcherService.on(AppEventTypeEnum.CLIENT_INVITE_ACCEPTED)
+      .subscribe((): void => {
+        this.fetch().subscribe((clientMovements: ClientMovement[]) => {
+          this.cache = clientMovements;
+          this.updateCache();
+        });
+      });
+  }
+}