@ikas/storefront 1.0.21 → 2.0.0-alpha.1

package/src/models/ui/blog-category-list/index.ts

@@ -0,0 +1,199 @@
+import { makeAutoObservable } from "mobx";
+import { IkasBlogCategory } from "../../../models/data/blog";
+import { IkasBlogCategoryListPropValue } from "../../../models/theme/page/component/prop-value/blog-category-list";
+import { IkasBlogAPI } from "../../../api";
+
+export class IkasBlogCategoryList {
+  data: IkasBlogCategory[];
+  private _type: IkasBlogCategoryListType;
+  private _limit: number;
+  private _page: number;
+  private _count: number;
+  private _initialized = false;
+  private _minPage?: number | null = null;
+  private _blogCategoryListPropValue: IkasBlogCategoryListPropValue;
+
+  private _isLoading = false;
+
+  constructor(data: IkasBlogCategoryListParams) {
+    this.data = data.data ? data.data.map((b) => new IkasBlogCategory(b)) : [];
+    this._type =
+      data.type ||
+      data.blogCategoryListPropValue.blogCategoryListType ||
+      IkasBlogCategoryListType.ALL;
+    this._limit =
+      data.limit || data.blogCategoryListPropValue.initialLimit || 20;
+    this._page = data.page || 1;
+    this._count = data.count || 0;
+    this._initialized = data.initialized || false;
+    this._minPage = data.minPage;
+    this._blogCategoryListPropValue = data.blogCategoryListPropValue;
+
+    makeAutoObservable(this);
+  }
+
+  get limit() {
+    return this._limit;
+  }
+
+  get page() {
+    return this._page;
+  }
+
+  get count() {
+    return this._count;
+  }
+
+  get pageCount() {
+    return Math.ceil(this._count / this._limit);
+  }
+
+  get isInitialized() {
+    return this._initialized;
+  }
+
+  get isStatic() {
+    return this._type === IkasBlogCategoryListType.STATIC;
+  }
+
+  get hasPrev() {
+    if (this.isStatic || !this._minPage) return false;
+    return this._minPage > 1;
+  }
+
+  get hasNext() {
+    if (this.isStatic) return false;
+    return this.page * this.limit < this.count;
+  }
+
+  get isLoading() {
+    return this._isLoading;
+  }
+
+  private async listBlogCategories(page: number, limit: number) {
+    return await IkasBlogAPI.listBlogCategory({
+      idList: this.isStatic
+        ? this._blogCategoryListPropValue.blogCategoryIds || undefined
+        : undefined,
+      page,
+      limit,
+    });
+  }
+
+  // Used by the provider
+  private getInitial = async () => {
+    if (this._isLoading) return;
+    this._isLoading = true;
+
+    try {
+      const response = await this.listBlogCategories(
+        this.isStatic ? 1 : this.page,
+        this.isStatic
+          ? this._blogCategoryListPropValue.blogCategoryIds?.length || 10
+          : this.limit
+      );
+
+      if (this.isStatic) {
+        this.data =
+          (this._blogCategoryListPropValue.blogCategoryIds
+            ?.map((bID) => {
+              return response.blogCategories.find((b) => b.id === bID);
+            })
+            .filter((b) => !!b) as IkasBlogCategory[]) || [];
+      } else {
+        this.data = response.blogCategories;
+      }
+
+      this._count = response.count;
+      this._initialized = true;
+      this._minPage = this.page;
+    } catch (err) {
+      console.log(err);
+    } finally {
+      this._isLoading = false;
+    }
+  };
+
+  getPrev = async () => {
+    if (this.isStatic || this._isLoading || !this.hasPrev) return;
+
+    this._isLoading = true;
+
+    try {
+      const minPage = this._minPage! - 1;
+      const response = await this.listBlogCategories(minPage, this.limit);
+
+      this.data = response.blogCategories.concat(this.data);
+      this._count = response.count;
+      this._minPage = minPage;
+    } catch (err) {
+      console.log(err);
+    } finally {
+      this._isLoading = false;
+    }
+  };
+
+  getNext = async () => {
+    if (this.isStatic || this._isLoading || !this.hasNext) return;
+    this._isLoading = true;
+
+    try {
+      const response = await this.listBlogCategories(this.page + 1, this.limit);
+
+      this.data = this.data.concat(response.blogCategories);
+      this._count = response.count;
+      this._page = this.page + 1;
+    } catch (err) {
+      console.log(err);
+    } finally {
+      this._isLoading = false;
+    }
+  };
+
+  getPage = async (page: number) => {
+    if (this._isLoading || this.isStatic) return;
+    this._isLoading = true;
+
+    try {
+      const response = await this.listBlogCategories(page, this.limit);
+
+      this.data = response.blogCategories;
+      this._count = response.count;
+      this._page = page;
+      this._minPage = page;
+    } catch (err) {
+      console.log(err);
+    } finally {
+      this._isLoading = false;
+    }
+  };
+
+  toJSON() {
+    return {
+      data: this.data,
+      type: this._type,
+      limit: this._limit,
+      page: this._page,
+      count: this._count,
+      initialized: this._initialized,
+      minPage: this._minPage,
+      blogCategoryListPropValue: this._blogCategoryListPropValue,
+    };
+  }
+}
+
+export type IkasBlogCategoryListParams = {
+  data?: IkasBlogCategory[];
+  type?: IkasBlogCategoryListType;
+  limit?: number;
+  page?: number;
+  count?: number;
+  initialized?: boolean;
+  minPage?: number;
+  blogCategoryListPropValue: IkasBlogCategoryListPropValue;
+};
+
+export enum IkasBlogCategoryListType {
+  ALL = "ALL",
+  STATIC = "STATIC",
+}

package/src/models/ui/blog-list/index.ts

@@ -0,0 +1,202 @@
+import { makeAutoObservable } from "mobx";
+import { IkasBlog } from "../../../models/data/blog";
+import { IkasBlogListPropValue } from "../../../models/theme/page/component/prop-value/blog-list";
+import { IkasBlogAPI } from "../../../api";
+
+export class IkasBlogList {
+  data: IkasBlog[];
+  private _type: IkasBlogListType;
+  private _limit: number;
+  private _page: number;
+  private _count: number;
+  private _initialized = false;
+  private _minPage?: number | null = null;
+  private _blogListPropValue: IkasBlogListPropValue;
+  private _filterCategoryId: string | null = null;
+
+  private _isLoading = false;
+
+  constructor(data: IkasBlogListParams) {
+    this.data = data.data ? data.data.map((b) => new IkasBlog(b)) : [];
+    this._type =
+      data.type || data.blogListPropValue.blogListType || IkasBlogListType.ALL;
+    this._limit = data.limit || data.blogListPropValue.initialLimit || 20;
+    this._page = data.page || 1;
+    this._count = data.count || 0;
+    this._initialized = data.initialized || false;
+    this._minPage = data.minPage;
+    this._blogListPropValue = data.blogListPropValue;
+    this._filterCategoryId = data.filterCategoryId || null;
+
+    makeAutoObservable(this);
+  }
+
+  get limit() {
+    return this._limit;
+  }
+
+  get page() {
+    return this._page;
+  }
+
+  get count() {
+    return this._count;
+  }
+
+  get pageCount() {
+    return Math.ceil(this._count / this._limit);
+  }
+
+  get isInitialized() {
+    return this._initialized;
+  }
+
+  get isStatic() {
+    return this._type === IkasBlogListType.STATIC;
+  }
+
+  get hasPrev() {
+    if (this.isStatic || !this._minPage) return false;
+    return this._minPage > 1;
+  }
+
+  get hasNext() {
+    if (this.isStatic) return false;
+    return this.page * this.limit < this.count;
+  }
+
+  get isLoading() {
+    return this._isLoading;
+  }
+
+  private async listBlogs(page: number, limit: number) {
+    return await IkasBlogAPI.listBlog({
+      idList: this.isStatic
+        ? this._blogListPropValue.blogIds || undefined
+        : undefined,
+      page,
+      limit,
+      categoryId: this._filterCategoryId || undefined,
+    });
+  }
+
+  // Used by the provider
+  private getInitial = async () => {
+    if (this._isLoading) return;
+    this._isLoading = true;
+
+    try {
+      const response = await this.listBlogs(
+        this.isStatic ? 1 : this.page,
+        this.isStatic
+          ? this._blogListPropValue.blogIds?.length || 10
+          : this.limit
+      );
+
+      if (this.isStatic) {
+        this.data =
+          (this._blogListPropValue.blogIds
+            ?.map((bID) => {
+              return response.blogs.find((b) => b.id === bID);
+            })
+            .filter((b) => !!b) as IkasBlog[]) || [];
+      } else {
+        this.data = response.blogs;
+      }
+
+      this._count = response.count;
+      this._initialized = true;
+      this._minPage = this.page;
+    } catch (err) {
+      console.log(err);
+    } finally {
+      this._isLoading = false;
+    }
+  };
+
+  getPrev = async () => {
+    if (this.isStatic || this._isLoading || !this.hasPrev) return;
+
+    this._isLoading = true;
+
+    try {
+      const minPage = this._minPage! - 1;
+      const response = await this.listBlogs(minPage, this.limit);
+
+      this.data = response.blogs.concat(this.data);
+      this._count = response.count;
+      this._minPage = minPage;
+    } catch (err) {
+      console.log(err);
+    } finally {
+      this._isLoading = false;
+    }
+  };
+
+  getNext = async () => {
+    if (this.isStatic || this._isLoading || !this.hasNext) return;
+    this._isLoading = true;
+
+    try {
+      const response = await this.listBlogs(this.page + 1, this.limit);
+
+      this.data = this.data.concat(response.blogs);
+      this._count = response.count;
+      this._page = this.page + 1;
+    } catch (err) {
+      console.log(err);
+    } finally {
+      this._isLoading = false;
+    }
+  };
+
+  getPage = async (page: number) => {
+    if (this._isLoading || this.isStatic) return;
+    this._isLoading = true;
+
+    try {
+      const response = await this.listBlogs(page, this.limit);
+
+      this.data = response.blogs;
+      this._count = response.count;
+      this._page = page;
+      this._minPage = page;
+    } catch (err) {
+      console.log(err);
+    } finally {
+      this._isLoading = false;
+    }
+  };
+
+  toJSON() {
+    return {
+      data: this.data,
+      type: this._type,
+      limit: this._limit,
+      page: this._page,
+      count: this._count,
+      initialized: this._initialized,
+      minPage: this._minPage,
+      blogListPropValue: this._blogListPropValue,
+      filterCategoryId: this._filterCategoryId,
+    };
+  }
+}
+
+export type IkasBlogListParams = {
+  data?: IkasBlog[];
+  type?: IkasBlogListType;
+  limit?: number;
+  page?: number;
+  count?: number;
+  initialized?: boolean;
+  minPage?: number;
+  blogListPropValue: IkasBlogListPropValue;
+  filterCategoryId: string | null;
+};
+
+export enum IkasBlogListType {
+  ALL = "ALL",
+  STATIC = "STATIC",
+  CATEGORY = "CATEGORY",
+}

package/src/models/ui/brand-list/index.ts

@@ -0,0 +1,239 @@
+import { IkasBrand } from "../../../models/data";
+import { IkasBrandAPI } from "../../../api";
+import { makeAutoObservable, runInAction } from "mobx";
+import { IkasBrandListPropValue } from "../../../models/theme/page/component/prop-value/brand-list";
+
+export class IkasBrandList {
+  data: IkasBrand[];
+  private _type: IkasBrandListType;
+  private _sort: IkasBrandListSortType;
+  private _limit: number;
+  private _page: number;
+  private _count: number;
+  private _initialized = false;
+  private _minPage?: number | null = null;
+  private _brandListPropValue: IkasBrandListPropValue;
+
+  private _isLoading = false;
+
+  constructor(data: IkasBrandListParams) {
+    this.data = data.data ? data.data.map((b) => new IkasBrand(b)) : [];
+    this._type =
+      data.type ||
+      data.brandListPropValue.brandListType ||
+      IkasBrandListType.ALL;
+    this._sort =
+      data.sort ||
+      data.brandListPropValue.initialSort ||
+      IkasBrandListSortType.A_Z;
+    this._limit = data.limit || data.brandListPropValue.initialLimit || 20;
+    this._page = data.page || 1;
+    this._count = data.count || 0;
+    this._initialized = data.initialized || false;
+    this._minPage = data.minPage;
+    this._brandListPropValue = data.brandListPropValue;
+
+    makeAutoObservable(this);
+  }
+
+  get sort() {
+    return this._sort;
+  }
+
+  get limit() {
+    return this._limit;
+  }
+
+  get page() {
+    return this._page;
+  }
+
+  get count() {
+    return this._count;
+  }
+
+  get pageCount() {
+    return Math.ceil(this._count / this._limit);
+  }
+
+  get isInitialized() {
+    return this._initialized;
+  }
+
+  get isStatic() {
+    return this._type === IkasBrandListType.STATIC;
+  }
+
+  get hasPrev() {
+    if (this.isStatic || !this._minPage) return false;
+    return this._minPage > 1;
+  }
+
+  get hasNext() {
+    if (this.isStatic) return false;
+    return this.page * this.limit < this.count;
+  }
+
+  get isLoading() {
+    return this._isLoading;
+  }
+
+  private getSortParams() {
+    if (this._sort === IkasBrandListSortType.A_Z) return "name";
+    else return "-name";
+  }
+
+  getInitial = async () => {
+    if (this._isLoading) return;
+    this._isLoading = true;
+
+    try {
+      const response = await IkasBrandAPI.listBrands({
+        idList: this.isStatic
+          ? this._brandListPropValue.brandIds || undefined
+          : undefined,
+        page: this.isStatic ? undefined : this.page,
+        limit: this.isStatic ? undefined : this.limit,
+        sort: this.getSortParams(),
+      });
+
+      if (this.isStatic) {
+        this.data =
+          (this._brandListPropValue.brandIds
+            ?.map((bID) => {
+              return response.brands.find((b) => b.id === bID);
+            })
+            .filter((b) => !!b) as IkasBrand[]) || [];
+      } else {
+        this.data = response.brands;
+      }
+
+      this._count = response.count;
+      this._initialized = true;
+      this._minPage = this.page;
+    } catch (err) {
+      console.log(err);
+    } finally {
+      runInAction(() => {
+        this._isLoading = false;
+      });
+    }
+  };
+
+  getPrev = async () => {
+    if (this.isStatic || this._isLoading || !this.hasPrev) return;
+
+    this._isLoading = true;
+
+    try {
+      const minPage = this._minPage! - 1;
+      const response = await IkasBrandAPI.listBrands({
+        page: minPage,
+        limit: this.limit,
+        sort: this.getSortParams(),
+      });
+      runInAction(() => {
+        this.data = response.brands.concat(this.data);
+        this._count = response.count;
+        this._minPage = minPage;
+      });
+    } catch (err) {
+      console.log(err);
+    } finally {
+      runInAction(() => {
+        this._isLoading = false;
+      });
+    }
+  };
+
+  getNext = async () => {
+    if (this.isStatic || this._isLoading || !this.hasNext) return;
+    this._isLoading = true;
+
+    try {
+      const response = await IkasBrandAPI.listBrands({
+        page: this.page + 1,
+        limit: this.limit,
+        sort: this.getSortParams(),
+      });
+      runInAction(() => {
+        this.data = this.data.concat(response.brands);
+        this._count = response.count;
+        this._page = this.page + 1;
+      });
+    } catch (err) {
+      console.log(err);
+    } finally {
+      runInAction(() => {
+        this._isLoading = false;
+      });
+    }
+  };
+
+  getPage = async (page: number) => {
+    if (this._isLoading || this.isStatic) return;
+    this._isLoading = true;
+
+    try {
+      const response = await IkasBrandAPI.listBrands({
+        page: page,
+        limit: this.limit,
+        sort: this.getSortParams(),
+      });
+
+      runInAction(() => {
+        this.data = response.brands;
+        this._count = response.count;
+        this._page = page;
+        this._minPage = page;
+      });
+    } catch (err) {
+      console.log(err);
+    } finally {
+      runInAction(() => {
+        this._isLoading = false;
+      });
+    }
+  };
+
+  async setSortType(sortType: IkasBrandListSortType) {
+    this._sort = sortType;
+    await this.getInitial();
+  }
+
+  toJSON() {
+    return {
+      data: this.data,
+      type: this._type,
+      sort: this._sort,
+      limit: this._limit,
+      page: this._page,
+      count: this._count,
+      initialized: this._initialized,
+      minPage: this._minPage,
+      brandListPropValue: this._brandListPropValue,
+    };
+  }
+}
+
+export type IkasBrandListParams = {
+  data?: IkasBrand[];
+  type?: IkasBrandListType;
+  sort?: IkasBrandListSortType;
+  limit?: number;
+  page?: number;
+  count?: number;
+  initialized?: boolean;
+  minPage?: number;
+  brandListPropValue: IkasBrandListPropValue;
+};
+
+export enum IkasBrandListType {
+  ALL = "ALL",
+  STATIC = "STATIC",
+}
+
+export enum IkasBrandListSortType {
+  A_Z = "A_Z",
+  Z_A = "Z_A",
+}