financial-assistant

1
import { EventTypes, Links } from "../contracts/enums";
2
import { Categories } from "../contracts/interfaces";
3
import EventObserver from "../observer/observer";
4
import Api from "./api";
5
import { ResponseType } from "../contracts/interfaces";
6

7
class Model {
8
  private api: Api;
9
  private observer: EventObserver;
10

11
  constructor(observer: EventObserver) {
12
    this.api = new Api();
13
    this.observer = observer;
14

15
    this.observer.subscribe(
16
      EventTypes.ENTER_PRESSED,
17
      this.getAssistantAnswer.bind(this)
18
    );
19
  }
20

21
  public onButtonClicked(
22
    buttonsTag: HTMLDivElement,
23
    path: Links,
24
    clickedValue?: Links
25
  ): void {
26
    buttonsTag.childNodes.forEach((node) => {
27
      node.addEventListener("click", (e) => {
28
        e.preventDefault();
29
        if (node instanceof HTMLElement && clickedValue)
30
          localStorage.setItem(clickedValue, node.id);
31
        this.observer.notify(EventTypes.CHANGE_PAGE, path);
32
      });
33
    });
34
  }
35

36
  private getLSItem(item: Links): string | null {
37
    return localStorage.getItem(item);
38
  }
39

40
  private removeLSItem(item: Links): void {
41
    localStorage.removeItem(item);
42
  }
43

44
  public async getBanks(): Promise<ResponseType[] | []> {
45
    const banks = await this.api.fetchBanks();
46
    return banks;
47
  }
48

49
  public async getProducts(): Promise<ResponseType[] | []> {
50
    const products = await this.api.fetchProducts();
51
    return products;
52
  }
53

54
  public async getProductCategories(): Promise<Categories[] | []> {
55
    const bankID = this.getLSItem(Links.banks);
56
    const productID = this.getLSItem(Links.products);
57

58
    if (!bankID || !productID) return [];
59

60
    const categories = await this.api.fetchProductsCategories(
61
      Number(bankID),
62
      Number(productID)
63
    );
64

65
    this.removeLSItem(Links.banks);
66
    this.removeLSItem(Links.products);
67

68
    return categories;
69
  }
70

71
  public async getCategorySubsections(): Promise<ResponseType[] | []> {
72
    const categoryID = this.getLSItem(Links.categories);
73
    if (!categoryID) return [];
74

75
    const subsections = await this.api.fetchCategorySubsections(
76
      Number(categoryID)
77
    );
78

79
    this.removeLSItem(Links.categories);
80
    return subsections;
81
  }
82

83
  public async getSubsectionDetails() {
84
    const subsectionID = this.getLSItem(Links.category_subsections);
85
    if (!subsectionID) return [];
86

87
    const subsectionDetails = await this.api.fetchSubsectionDetails(
88
      Number(subsectionID)
89
    );
90

91
    this.removeLSItem(Links.category_subsections);
92
    return subsectionDetails;
93
  }
94

95
  public async getDetailedData() {
96
    const detailID = this.getLSItem(Links.subsection_details);
97
    if (!detailID) return [];
98

99
    const detailedInfo = await this.api.fetchDetailedData(Number(detailID));
100

101
    this.removeLSItem(Links.subsection_details);
102
    return detailedInfo;
103
  }
104

105
  public async getAssistantAnswer(query: string) {
106
    const answer = await this.api.assistant(query);
107
    this.observer.notify(EventTypes.ASSISTANT_ANSWER, answer);
108
  }
109
}
110

111
export default Model;
112

113