@reachu/database 1.0.0

package/src/entity/Order.ts

@@ -0,0 +1,80 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+  DeleteDateColumn,
+} from 'typeorm';
+import User from './User';
+import AuditedModel from './AuditedModel';
+import OrderItem from './OrderItem';
+import OrderCustomer from './OrderCustomer';
+import OrderTracking from './OrderTracking';
+import Currency from '../staticData/Currency';
+import OrderShipping from './OrderShipping';
+import { Price } from './Price.entity';
+
+@Entity()
+class Order extends AuditedModel {
+  @PrimaryGeneratedColumn()
+  id?: number;
+
+  @Column('varchar')
+  channel: string;
+
+  @Column('varchar')
+  channelId: string;
+
+  @Column('varchar')
+  channelOrderName: string;
+
+  @Column('datetime')
+  channelCreatedDate: Date;
+
+  @Column('varchar')
+  currency: Currency;
+
+  @Column('varchar', { nullable: true })
+  paymentProcessor?: string;
+
+  @Column(() => OrderCustomer, { prefix: 'customer_' })
+  customer: OrderCustomer;
+
+  @ManyToOne(() => User, { eager: true })
+  @JoinColumn()
+  reseller: User;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  shippingPrice?: number;
+
+  @Column('varchar', { nullable: true })
+  shippingTitle?: string;
+
+  @Column('varchar', { nullable: true })
+  shippingCode?: string;
+
+  @Column('varchar', { nullable: true })
+  sscc?: string;
+
+  @OneToMany(() => OrderItem, (item: OrderItem) => item.order, { cascade: true })
+  @JoinColumn()
+  items: OrderItem[];
+
+  @OneToMany(() => OrderShipping, (item: OrderShipping) => item.order, { cascade: true })
+  @JoinColumn()
+  shippingItems: OrderShipping[];
+
+  @OneToMany(() => OrderTracking, (tracking) => tracking.order, { cascade: true })
+  @JoinColumn()
+  trackings: OrderTracking[];
+
+  @DeleteDateColumn()
+  deletedAt: Date;
+
+  @Column(() => Price, { prefix: 'price_' })
+  price: Price;
+}
+
+export default Order;

package/src/entity/OrderCustomer.ts

@@ -0,0 +1,48 @@
+import { Column } from 'typeorm';
+
+export default class OrderCustomer {
+  @Column('varchar')
+  fullName: string;
+
+  @Column('varchar', { nullable: true })
+  email?: string;
+
+  @Column('varchar', { nullable: true })
+  phone?: string;
+
+  @Column('varchar')
+  shippingZip: string;
+
+  @Column('varchar')
+  shippingAddress: string;
+
+  @Column('varchar')
+  shippingCity: string;
+
+  @Column('varchar', { nullable: true })
+  shippingState?: string;
+
+  @Column('varchar')
+  shippingCountry: string;
+
+  @Column('varchar')
+  shippingContactName: string;
+
+  @Column('varchar')
+  billingName: string;
+
+  @Column('varchar')
+  billingZip: string;
+
+  @Column('varchar')
+  billingCity: string;
+
+  @Column('varchar', { nullable: true })
+  billingState?: string;
+
+  @Column('varchar')
+  billingAddress: string;
+
+  @Column('varchar')
+  billingCountry: string;
+}

package/src/entity/OrderItem.ts

@@ -0,0 +1,118 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  JoinColumn,
+  ManyToOne,
+  Column,
+  AfterLoad,
+  OneToOne,
+  DeleteDateColumn,
+} from 'typeorm';
+import Order from './Order';
+import User from './User';
+import { Product } from './Product.entity';
+import PaymentShopify from './PaymentShopify';
+import OrderTracking from './OrderTracking';
+
+@Entity()
+export default class OrderItem {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @DeleteDateColumn()
+  deletedAt: Date;
+
+  @ManyToOne(() => Product, { eager: true })
+  @JoinColumn()
+  product: Product;
+
+  @ManyToOne(() => OrderTracking, { eager: true })
+  @JoinColumn()
+  orderTracking: OrderTracking;
+
+  @ManyToOne(() => User, { eager: true, onDelete: 'CASCADE' })
+  @JoinColumn()
+  supplier: User;
+
+  @ManyToOne(() => Order, (order: Order) => order.items, { eager: true, onDelete: 'CASCADE' })
+  @JoinColumn()
+  order: Order;
+
+  @Column('integer')
+  quantity: number;
+
+  @Column('varchar', { nullable: true })
+  sku?: string;
+
+  @Column('varchar')
+  variantTitle: string;
+
+  @Column('decimal', { precision: 10, scale: 2 })
+  price: number;
+
+  @Column('decimal', { precision: 10, scale: 2 })
+  priceChannel: number;
+
+  @Column('varchar')
+  currencyChannel: string;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  tax?: number;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  taxRate?: number;
+
+  @Column('varchar', { nullable: true })
+  taxTitle?: string;
+
+  @Column('decimal', { precision: 10, scale: 2 })
+  profit: number;
+
+  @Column('decimal', { precision: 10, scale: 2 })
+  revenue: number;
+
+  @Column('decimal', { precision: 10, scale: 2 })
+  fee: number;
+
+  @Column('varchar')
+  status: string;
+
+  @Column('varchar', { nullable: true })
+  statusDetail?: string;
+
+  @Column('varchar', { nullable: true })
+  statusReason?: string;
+
+  @Column('boolean', { default: false })
+  isSalesChannel: boolean;
+
+  @OneToOne(() => PaymentShopify, { eager: true })
+  @JoinColumn()
+  paymentShopify: PaymentShopify;
+
+  @Column('varchar', { nullable: true })
+  supplierWooOrderId?: string;
+
+  @Column('varchar', { nullable: true })
+  supplierShopifyOrderId?: string;
+
+  @Column('varchar', { nullable: true })
+  supplierExternalOrderId?: string;
+
+  @Column('varchar', { nullable: true })
+  supplierExternalOrderChannel?: string;
+
+  @Column('varchar', { nullable: true })
+  channelId?: string;
+
+  @AfterLoad()
+  convertNumerics() {
+    this.price = parseFloat(String(this.price));
+    this.priceChannel = parseFloat(String(this.priceChannel));
+    this.tax = parseFloat(String(this.tax));
+    this.taxRate = parseFloat(String(this.taxRate));
+    this.profit = parseFloat(String(this.profit));
+    this.fee = parseFloat(String(this.fee));
+    this.revenue = parseFloat(String(this.revenue));
+  }
+}

package/src/entity/OrderShipping.ts

@@ -0,0 +1,47 @@
+import {
+  AfterLoad,
+  Column,
+  DeleteDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+import Order from './Order';
+
+@Entity()
+export default class OrderShipping {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @DeleteDateColumn()
+  deletedAt: Date;
+
+  @ManyToOne(() => Order, (order: Order) => order.shippingItems, {
+    eager: true,
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn()
+  order: Order;
+
+  @Column('varchar')
+  code: string;
+
+  @Column('varchar')
+  title: string;
+
+  @Column('decimal', { precision: 10, scale: 2 })
+  price: number;
+
+  @Column('decimal', { precision: 10, scale: 2 })
+  priceChannel: number;
+
+  @Column('boolean', { default: false })
+  captured: boolean;
+
+  @AfterLoad()
+  convertNumerics() {
+    this.price = parseFloat(String(this.price));
+    this.priceChannel = parseFloat(String(this.priceChannel));
+  }
+}

package/src/entity/OrderTracking.ts

@@ -0,0 +1,50 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  ManyToOne,
+  JoinColumn,
+  Column,
+  DeleteDateColumn,
+} from 'typeorm';
+import Order from './Order';
+import AuditedModel from './AuditedModel';
+
+@Entity()
+export default class OrderTracking extends AuditedModel {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @ManyToOne(() => Order, { onDelete: 'CASCADE' })
+  @JoinColumn()
+  order: Order;
+
+  @Column('varchar', { nullable: true })
+  trackingNumber?: string;
+
+  @Column('varchar', { nullable: true })
+  slug?: string;
+
+  @Column('varchar', { nullable: true })
+  url?: string;
+
+  @Column('varchar', { nullable: true })
+  processor?: string;
+
+  @Column('varchar', { nullable: true })
+  processorId?: string;
+
+  @Column('varchar', { nullable: true })
+  status?: string;
+
+  @Column('datetime', { nullable: true })
+  statusDate?: Date;
+
+  @Column('varchar', { nullable: true })
+  resellerFulfillmentId?: string;
+
+  @Column('varchar', { nullable: true })
+  supplierFulfillmentIds?: string;
+
+  @DeleteDateColumn()
+  deletedAt: Date;
+}

package/src/entity/Payment.ts

@@ -0,0 +1,52 @@
+import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, ManyToOne } from 'typeorm';
+import User from './User';
+import AuditedModel from './AuditedModel';
+
+@Entity()
+export default class Payment extends AuditedModel {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column('varchar')
+  mangopayId: string;
+
+  @ManyToOne(() => User, { eager: true, onDelete: 'CASCADE' })
+  @JoinColumn()
+  author: User;
+
+  @Column('varchar')
+  cardId: string;
+
+  @Column('bigint')
+  relatedEntityId: number;
+
+  @Column('varchar')
+  relatedEntityType: string;
+
+  @Column('varchar', { nullable: true })
+  refundId: string;
+
+  @Column('varchar')
+  status: string;
+
+  @Column('varchar')
+  walletId: string;
+
+  @Column('integer')
+  amount: number;
+
+  @Column('varchar', { nullable: true })
+  currency: string;
+
+  @Column('integer')
+  fee: number;
+
+  @Column('boolean')
+  secureMode: boolean;
+
+  @Column('varchar', { nullable: true })
+  secureRedirectUrl: string;
+
+  @Column('varchar', { nullable: true })
+  secureReturnUrl: string;
+}

package/src/entity/PaymentMethod.ts

@@ -0,0 +1,32 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  DeleteDateColumn,
+  JoinColumn,
+  Column,
+  ManyToOne,
+} from 'typeorm';
+import AuditedModel from './AuditedModel';
+import User from './User';
+
+@Entity()
+export default class PaymentMethod extends AuditedModel {
+  @DeleteDateColumn()
+  deletedAt: Date;
+
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column('boolean', { default: false })
+  active?: boolean;
+
+  @Column('varchar', { length: '21844', nullable: true })
+  options: string;
+
+  @ManyToOne(() => User, (user: User) => user.id, {
+    eager: true,
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn()
+  user: User;
+}

package/src/entity/PaymentShopify.ts

@@ -0,0 +1,17 @@
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+import AuditedModel from './AuditedModel';
+
+@Entity()
+export default class PaymentShopify extends AuditedModel {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column('varchar')
+  shopifyId: string;
+
+  @Column('varchar')
+  confirmationUrl: string;
+
+  @Column('varchar')
+  status: string;
+}

package/src/entity/Permission.ts

@@ -0,0 +1,13 @@
+import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+
+@Entity()
+export default class Permission {
+  @PrimaryGeneratedColumn()
+  idPermission: number;
+
+  @Column('varchar', { nullable: false })
+  permission: string;
+
+  @Column('boolean', { default: true, nullable: false })
+  activePermission: boolean;
+}

package/src/entity/Price.entity.ts

@@ -0,0 +1,12 @@
+import { Column } from 'typeorm';
+
+export class Price {
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  amount?: number;
+
+  @Column('varchar', { nullable: true })
+  currencyCode?: string;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  baseAmount?: number;
+}

package/src/entity/Product.entity.ts

@@ -0,0 +1,200 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  JoinColumn,
+  ManyToMany,
+  JoinTable,
+  ManyToOne,
+  OneToMany,
+  AfterLoad,
+  DeleteDateColumn,
+  OneToOne,
+  getRepository,
+} from 'typeorm';
+import User from './User';
+import Subcategory from './Subcategory';
+import Channel from './Channel';
+import AuditedModel from './AuditedModel';
+import Option from './Option';
+import Image from './Image';
+import Variant from './Variant';
+import FlatRate from './FlatRate';
+import ImportedProduct from './ImportedProduct';
+import { logger } from '@reachu/logger';
+import { currencies } from '../staticData/Currency';
+import { Price } from './Price.entity';
+import ProductShipping from './modules/shipping/ProductShipping';
+import { CustomProduct } from './CustomProduct';
+
+@Entity()
+export class Product extends AuditedModel {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @DeleteDateColumn()
+  deletedAt: Date;
+
+  @Column('varchar', { nullable: true })
+  title?: string;
+
+  @Column('integer', { default: 0 })
+  status: number;
+
+  @Column('text', { nullable: true })
+  description?: string;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  publicPrice?: number;
+
+  @Column(() => Price, { prefix: 'price_' })
+  price: Price;
+
+  @Column('integer', { default: 10 })
+  referralFee: number;
+
+  @Column('varchar', { default: '', nullable: true })
+  tags?: string;
+
+  @Column('varchar', { nullable: true })
+  sku?: string;
+
+  @Column('varchar', { nullable: true })
+  barcode?: string;
+
+  @Column('integer', { nullable: true })
+  quantity?: number;
+
+  @Column('boolean', { default: false })
+  allowPurchaseOutOfStock: boolean;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  weight?: number;
+
+  @Column('text', { nullable: true })
+  shipTo?: string;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  width?: number;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  height?: number;
+
+  @Column('decimal', { precision: 10, scale: 2, nullable: true })
+  depth?: number;
+
+  @Column('boolean', { default: false })
+  optionsEnabled: boolean;
+
+  @ManyToOne(() => User, { eager: true })
+  @JoinColumn()
+  user: User;
+
+  @ManyToMany(() => Subcategory, { eager: true })
+  @JoinTable()
+  subcategories: Subcategory[];
+
+  @ManyToMany(() => Channel, { eager: true })
+  @JoinTable()
+  channels: Channel[];
+
+  @OneToMany(() => Option, (option) => option.product, { eager: true, cascade: true })
+  @JoinColumn()
+  options: Option[];
+
+  @OneToMany(() => Variant, (variant) => variant.product, { eager: true, cascade: true })
+  @JoinColumn()
+  variants: Variant[];
+
+  @OneToMany(() => Image, (image) => image.product, { eager: true, cascade: true })
+  @JoinColumn()
+  images: Image[];
+
+  @Column('varchar', { nullable: true })
+  origin?: string;
+
+  @Column('varchar', { nullable: true })
+  originId?: string;
+
+  @Column('varchar', { nullable: true })
+  originVariantId?: string;
+
+  @OneToOne(() => FlatRate, { eager: true })
+  @JoinColumn()
+  flatRate: FlatRate;
+
+  // TODO: FIX? One to many
+  @OneToOne(() => ImportedProduct, (importedProduct) => importedProduct.product)
+  importedProduct: ImportedProduct;
+
+  @Column('varchar', { nullable: true, select: false })
+  totalOrders?: string;
+
+  @Column('varchar', { nullable: true, select: false })
+  totalImports?: string;
+
+  @Column('integer', { nullable: true, select: false })
+  imported?: number;
+
+  @Column('varchar', { nullable: true, select: false })
+  shopifyId?: string;
+
+  @Column('varchar', { nullable: true, select: false })
+  wooId?: string;
+
+  @Column('varchar', { nullable: true, select: false })
+  userIsSender?: string;
+
+  @Column('varchar', { nullable: true, select: false })
+  userIsReceiver?: string;
+
+  @Column('integer', { default: 0 })
+  rate: number;
+
+  @Column('boolean', { default: false })
+  migrated: boolean;
+
+  @Column('boolean', { default: false })
+  active: boolean;
+
+  revenue: number;
+
+  @OneToMany(() => ProductShipping, (productShipping: ProductShipping) => productShipping.product, {
+    cascade: true,
+  })
+  @JoinColumn()
+  productShipping: ProductShipping[];
+
+  @OneToMany(() => CustomProduct, (customProduct) => customProduct.product, { onDelete: 'CASCADE' })
+  @JoinColumn()
+  customProduct: CustomProduct;
+
+  @AfterLoad()
+  convertNumerics() {
+    const diff = (this.referralFee * this.publicPrice) / 100;
+    this.revenue = Math.round((this.publicPrice - diff) * 100) / 100;
+  }
+
+  static getCacheKey(id, currency) {
+    return `PRODUCT_${id}-${currency}`;
+  }
+
+  static async invalidateCache(productId, removeCache: (key: any) => Promise<void>) {
+    logger.debug(`[Product.invalidateCache]: by productId ${productId}`);
+    await Promise.all(
+      currencies.map((currency) => removeCache(this.getCacheKey(productId, currency))),
+    );
+  }
+
+  static async productsCountStatus(status) {
+    return getRepository(Product).count({ where: { status } });
+  }
+
+  static get PUBLISHED() {
+    return 1;
+  }
+
+  static get DRAFT() {
+    return 0;
+  }
+}

package/src/entity/Request.ts

@@ -0,0 +1,23 @@
+import { Entity, PrimaryGeneratedColumn, Column, JoinColumn, ManyToOne } from 'typeorm';
+import AuditedModel from './AuditedModel';
+import User from './User';
+
+@Entity()
+export default class Request extends AuditedModel {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @ManyToOne(() => User, { eager: true, onDelete: 'CASCADE' })
+  @JoinColumn()
+  sender: User;
+
+  @ManyToOne(() => User, { eager: true, onDelete: 'CASCADE' })
+  @JoinColumn()
+  receiver: User;
+
+  // 0 pending
+  // 1 accepted
+  // 2 denied
+  @Column('integer', { nullable: true, default: 0 })
+  state: number;
+}