@reachu/database 1.0.0

package/src/helpers/products/storage/search.ts

@@ -0,0 +1,249 @@
+import { Brackets, getRepository } from 'typeorm';
+import { logger } from '@reachu/logger';
+
+import Request from '../../../entity/Request';
+import ImportedProduct from '../../../entity/ImportedProduct';
+import OrderItem from '../../../entity/OrderItem';
+import { Product } from '../../../entity/Product.entity';
+
+export const find = async (page = 0, size = 10, filters = {}) => {
+  logger.debug(
+    `[productService.find] (page ${page}, size ${size}) by filters ${JSON.stringify(filters)}`,
+  );
+  const {
+    categories,
+    channels,
+    text,
+    priceFrom,
+    priceTo,
+    user,
+    hiddenUserId,
+    referralFeeFrom,
+    referralFeeTo,
+    shipTo,
+    status,
+    loggedUserId,
+    imported,
+  } = filters as any;
+
+  let queryBuilder;
+  if (!imported) {
+    queryBuilder = getRepository(Product)
+      .createQueryBuilder('product')
+      .select([
+        'product.id',
+        'product.createdAt',
+        'product.title',
+        'product.status',
+        'product.referralFee',
+        'product.rate',
+        'product.publicPrice',
+        'product.origin',
+        'product.originId',
+        'product.optionsEnabled',
+        'user.id',
+        'user.avatar',
+        'user.name',
+        'user.surname',
+      ])
+      .leftJoin('product.subcategories', 'subcategory')
+      .leftJoin('product.user', 'user')
+      .leftJoinAndSelect('product.images', 'images')
+      .leftJoin('product.channels', 'channel');
+
+    if (loggedUserId) {
+      queryBuilder.leftJoinAndMapOne(
+        'product.importedProduct',
+        ImportedProduct,
+        'importedProduct',
+        'importedProduct.product.id = product.id and importedProduct.user.id = :loggedUserId',
+        { loggedUserId },
+      );
+    }
+    if (loggedUserId && user !== loggedUserId) {
+      queryBuilder
+        .addSelect(
+          (sq) =>
+            sq
+              .select('COUNT(rr.id)')
+              .from(Request, 'rr')
+              .where(`rr.receiver.id = user.id AND rr.sender.id = ${loggedUserId}`),
+          'product_user_is_receiver',
+        )
+        .addSelect(
+          (sq) =>
+            sq
+              .select('COUNT(rs.id)')
+              .from(Request, 'rs')
+              .where(`rs.sender.id = user.id AND rs.receiver.id = ${loggedUserId}`),
+          'product_user_is_sender',
+        )
+        .leftJoinAndMapOne(
+          'product.request',
+          Request,
+          'request',
+          '(request.sender.id = user.id AND request.receiver.id = :userId) OR (request.receiver.id = user.id AND request.sender.id = :userId)',
+          { userId: loggedUserId },
+        );
+    }
+    if (status) {
+      queryBuilder.andWhere('product.status = :status', { status });
+    }
+    if (user) {
+      queryBuilder.andWhere('product.user.id = :user', { user });
+    }
+    if (hiddenUserId) {
+      queryBuilder.andWhere('product.user.id != :hiddenUserId', { hiddenUserId });
+    }
+    if (shipTo && shipTo.length) {
+      queryBuilder.andWhere(
+        new Brackets((sqb) => {
+          sqb.where('product.shipTo LIKE :shipTo', { shipTo: `%${shipTo[0]}%` });
+          for (let index = 1; index < shipTo.length; index += 1) {
+            sqb.orWhere(`product.shipTo LIKE :shipTo${index}`, {
+              [`shipTo${index}`]: `%${shipTo[index]}%`,
+            });
+          }
+        }),
+      );
+    }
+    if (categories && categories.length) {
+      queryBuilder.andWhere('subcategory.category.id IN (:...categories)', { categories });
+    }
+    if (channels && channels.length) {
+      queryBuilder.andWhere('channel.name IN (:...channels)', { channels });
+    }
+    if (text) {
+      queryBuilder.andWhere('product.title LIKE :text', { text: `%${text}%` });
+    }
+    if (priceFrom && priceTo) {
+      queryBuilder.andWhere('product.publicPrice BETWEEN :priceFrom AND :priceTo', {
+        priceFrom,
+        priceTo,
+      });
+    }
+    if (referralFeeFrom && referralFeeTo) {
+      queryBuilder.andWhere('product.referralFee BETWEEN :referralFeeFrom AND :referralFeeTo', {
+        referralFeeFrom,
+        referralFeeTo,
+      });
+    }
+
+    const { raw, entities } = await queryBuilder
+      .skip(page * size)
+      .take(size)
+      .orderBy('product.rate', 'DESC')
+      .addOrderBy('product.createdAt', 'DESC')
+      .getRawAndEntities();
+    const total = await queryBuilder.getCount();
+    const items = entities.map((entity) => {
+      const row = raw.find((r) => r.product_id === entity.id);
+      return {
+        ...entity,
+        userIsSender: row.product_user_is_sender,
+        userIsReceiver: row.product_user_is_receiver,
+      };
+    });
+    logger.debug(
+      `[productService.find] Found ${total} by (page ${page}, size ${size}) filters: ${JSON.stringify(
+        filters,
+      )}`,
+    );
+    return { items, total };
+  } else {
+    logger.debug(`[productService.find] by imported ${imported}`);
+    queryBuilder = getRepository(ImportedProduct)
+      .createQueryBuilder('importedProduct')
+      .leftJoinAndSelect('importedProduct.product', 'product')
+      .leftJoin('importedProduct.user', 'userImport')
+      .leftJoinAndSelect('product.user', 'user')
+      .leftJoinAndSelect('product.images', 'image')
+      .where('userImport.id = :userId', { userId: loggedUserId })
+      .andWhere('user.id != :userId', { userId: loggedUserId })
+      .andWhere('product.status = 1')
+      .leftJoin(
+        Request,
+        'request',
+        `(request.sender.id=user.id AND request.receiver.id=${loggedUserId}) OR (request.receiver.id=user.id AND request.sender.id=${loggedUserId})`,
+      )
+      .andWhere('request.state = 1');
+
+    const [items, total] = await queryBuilder
+      .skip(page * size)
+      .take(size)
+      .getManyAndCount();
+
+    items.forEach((item) => {
+      item.product.shopifyId = item.shopifyId;
+      item.product.wooId = item.wooId;
+    });
+    logger.debug(`[productService.find] Found ${total} by filters: ${JSON.stringify(filters)}`);
+    return { items: items.map((item) => item.product), total };
+  }
+};
+
+export const findById = async (id, loggedUser) => {
+  const product = await getRepository(Product)
+    .createQueryBuilder('product')
+    .select('product')
+    .addSelect(
+      (sq) =>
+        sq
+          .select('COUNT(orderItem.id)')
+          .from(OrderItem, 'orderItem')
+          .where('orderItem.product.id = product.id'),
+      'product_total_orders',
+    )
+    .addSelect(
+      (sq) =>
+        sq
+          .select('COUNT(importedProduct.id)')
+          .from(ImportedProduct, 'importedProduct')
+          .where('importedProduct.product.id = product.id')
+          .andWhere('importedProduct.user.id != product.user.id'),
+      'product_total_imports',
+    )
+    .addSelect(
+      (sq) =>
+        sq
+          .select('COUNT(rr.id)')
+          .from(Request, 'rr')
+          .where(`rr.receiver.id = user.id AND rr.sender.id = ${loggedUser.id}`),
+      'product_user_is_receiver',
+    )
+    .addSelect(
+      (sq) =>
+        sq
+          .select('COUNT(rs.id)')
+          .from(Request, 'rs')
+          .where(`rs.sender.id = user.id AND rs.receiver.id = ${loggedUser.id}`),
+      'product_user_is_sender',
+    )
+    .leftJoinAndSelect('product.subcategories', 'subcategory')
+    .leftJoinAndSelect('product.variants', 'variant')
+    .leftJoinAndSelect('product.options', 'option')
+    .leftJoinAndSelect('product.user', 'user')
+    .leftJoinAndSelect('product.images', 'image')
+    .leftJoinAndSelect('product.channels', 'channel')
+    .leftJoinAndSelect('product.flatRate', 'flatRate')
+    .leftJoinAndSelect('flatRate.countries', 'flatRateCountry')
+    .leftJoinAndMapOne(
+      'product.importedProduct',
+      ImportedProduct,
+      'importedProduct',
+      'importedProduct.product.id = product.id and importedProduct.user.id = :userId',
+      { userId: loggedUser.id },
+    )
+    .leftJoinAndMapOne(
+      'product.request',
+      Request,
+      'request',
+      '(request.sender.id = user.id AND request.receiver.id = :userId) OR (request.receiver.id = user.id AND request.sender.id = :userId)',
+      { userId: loggedUser.id },
+    )
+    .where('product.id = :productId', { productId: id })
+    .getOne();
+  logger.debug(`[productService.findById] Adding statistic information to product ${id}`);
+  // const user = await userService.addStatistics(product.user);
+  return { ...product /*, user */ };
+};

package/src/helpers/returns/index.ts

@@ -0,0 +1,2 @@
+import * as Storage from './storage';
+export { Storage };

package/src/helpers/returns/storage.ts

@@ -0,0 +1,9 @@
+import { getRepository } from 'typeorm';
+import OrderItem from '../../entity/OrderItem';
+
+const findOrderItemBy = async (productId, orderId) => {
+  const where = { product: { id: productId }, order: { id: orderId } };
+  return getRepository(OrderItem).findOne({ where });
+};
+
+export { findOrderItemBy };

package/src/helpers/statistics/connections.ts

@@ -0,0 +1,70 @@
+import { getRepository } from 'typeorm';
+import { Array } from '@reachu/utils';
+import User from '../../entity/User';
+import ImportedProduct from '../../entity/ImportedProduct';
+import ChannelName from '../../staticData/ChannelName';
+
+const usersWithConnections = async () => {
+  const userRepo = getRepository(User);
+  const query = userRepo
+    .createQueryBuilder('user')
+    .leftJoinAndSelect('user.shopifyReseller', 'shopifyReseller')
+    .where('shopifyReseller.accessToken IS NOT NULL')
+    .orWhere('user.facebookAccessToken IS NOT NULL')
+    .orWhere('user.woo_id IS NOT NULL');
+  return query.getCount();
+};
+
+const usersWithoutConnections = async () => {
+  const userRepo = getRepository(User);
+  const query = userRepo
+    .createQueryBuilder('user')
+    .leftJoinAndSelect('user.shopifyReseller', 'shopifyReseller')
+    .where('shopifyReseller.accessToken IS NULL')
+    .andWhere('user.facebookAccessToken IS NULL')
+    .andWhere('user.woo_id IS NULL');
+  return query.getCount();
+};
+
+const avgSavedProducts = async () => {
+  const [importedProducts, count] = await savedProducts();
+  const sellersLength = Array.uniqBy(importedProducts, (ip) => ip.user.id).length;
+  return Number((count / sellersLength).toFixed(2));
+};
+
+async function savedProducts() {
+  return await getRepository(ImportedProduct)
+    .createQueryBuilder('importedProduct')
+    .innerJoinAndSelect('importedProduct.user', 'seller')
+    .innerJoinAndSelect('importedProduct.product', 'product')
+    .innerJoinAndSelect('product.user', 'supplier')
+    .where('supplier.id <> seller.id')
+    .getManyAndCount();
+}
+
+const productsOnChannel = async (channel) => {
+  const queryBuilder = getRepository(ImportedProduct).createQueryBuilder('importedProduct');
+
+  if (channel === ChannelName.SHOPIFY) {
+    queryBuilder.where('shopify_id IS NOT NULL');
+  }
+  if (channel === ChannelName.WOO) {
+    queryBuilder.where('woo_id IS NOT NULL');
+  }
+  return await queryBuilder.getCount();
+};
+
+const usersWhoExportedProducts = async () => {
+  return await getRepository(ImportedProduct)
+    .createQueryBuilder('importedProduct')
+    .where('shopify_id IS NOT NULL OR woo_id IS NOT NULL')
+    .getCount();
+};
+
+export {
+  usersWithConnections,
+  usersWithoutConnections,
+  avgSavedProducts,
+  productsOnChannel,
+  usersWhoExportedProducts,
+};

package/src/helpers/statistics/index.ts

@@ -0,0 +1,2 @@
+import * as Connections from './connections';
+export { Connections };

package/src/index.ts

@@ -0,0 +1,8 @@
+import * as Migration from './migrations';
+import * as Entity from './entity';
+import * as StaticData from './staticData';
+import * as Utils from './utils';
+import * as Repository from './repositories';
+import * as Helper from './helpers';
+
+export { Migration, Entity, StaticData, Utils, Repository, Helper };

package/src/interface/connectionConfig.ts

@@ -0,0 +1,17 @@
+import { EntitySchema, EntitySubscriberInterface, MigrationInterface } from 'typeorm';
+import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
+
+export interface ConnectionConfig {
+  type: string;
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+  database: string;
+  namingStrategy: SnakeNamingStrategy;
+  entities: EntitySchema<any>[];
+  synchronize: boolean;
+  timezone: string;
+  migrations: MigrationInterface[];
+  subscribers: EntitySubscriberInterface<any>[];
+}