@things-factory/operato-hub 4.3.76 → 4.3.79-alpha.0

package/server/routers/api/restful-apis/v1/warehouse/get-inventory-product-group-list.ts

@@ -0,0 +1,295 @@
+import { EntityManager, getConnection } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { LOCATION_TYPE } from '@things-factory/warehouse-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { validateLimitOffset } from '../utils/validate-util'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-inventory-product-group-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
+
+      // optional query parameter filter
+      let filter = { ...context.query }
+
+      delete filter['limit']
+      delete filter['offset']
+
+      let filters = []
+      if (filter.hasOwnProperty('sku')) {
+        filters.push({ name: 'productSKU', operator: 'eq', value: filter['sku'] })
+      }
+      if (filter.hasOwnProperty('batchId')) {
+        filters.push({ name: 'batchId', operator: 'eq', value: filter['batchId'] })
+      }
+
+      await getConnection().transaction(async (tx: EntityManager) => {
+        let customerBizplaceId = filter.bizplaceId
+        const customerCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, customerBizplaceId, tx)
+        const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+          where: { id: customerBizplaceId },
+          relations: ['company', 'company.domain']
+        })
+
+        const bizplaces: Bizplace[] = [customerBizplace, customerCompanyBizplace]
+        const params: any = { filters, pagination: { page: offset, limit: limit } }
+
+        const { items, total } = await bizplaceInventoryProductGroup(bizplaces, params, context, tx)
+
+        let data = items.map(item => {
+          return {
+            product: {
+              sku: item.productSKU,
+              name: item.productName,
+              description: item.productDescription,
+              type: item.groupType
+            },
+            batchId: item.batchId,
+            packingType: item.packingType,
+            packingSize: item.packingSize,
+            qty: item.remainQty,
+            uomValue: item.remainUomValue,
+            uom: item.uom
+          }
+        })
+
+        context.body = {
+          data,
+          totalCount: total,
+          limit,
+          offset
+        }
+      })
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)
+
+async function bizplaceInventoryProductGroup(bizplaces: Bizplace[], params, context: any, trxMgr: EntityManager) {
+  try {
+    let filters = params.filters
+    const { domain }: { domain: Domain } = context.state
+
+    const { bizplaceIds, productWhereClause, bundleWhereClause, whereClause, batchBundle } = await getConditions(
+      bizplaces,
+      filters
+    )
+
+    const _groupType = filters.find(res => res.name == 'groupType')
+
+    let queryStrings = `
+        CREATE TEMP TABLE temp_inventory_product_group AS (
+          SELECT * FROM (
+            WITH oi as (
+              SELECT
+                SUM(oi.release_qty) AS release_qty,
+                SUM(oi.release_uom_value) AS release_uom_value,
+                oi.batch_id,
+                oi.batch_id_ref,
+                oi.product_id,
+                p.name AS product_name,
+                oi.packing_type,
+                oi.packing_size,
+                oi.uom
+              FROM
+                order_inventories oi
+              LEFT JOIN
+                products p
+              ON
+                oi.product_id = p.id
+              WHERE
+                (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
+                AND oi.batch_id NOTNULL
+                AND oi.product_id NOTNULL
+                AND oi.packing_type NOTNULL
+                AND oi.packing_size NOTNULL
+                AND oi.inventory_id IS NULL
+              GROUP BY
+                oi.batch_id,
+                oi.batch_id_ref,
+                oi.product_id,
+                oi.packing_type,
+                oi.packing_size,
+                oi.uom,
+                p.name
+            )
+            SELECT
+              i.batch_id AS "batchId",
+              i.batch_id_ref AS "batchIdRef",
+              i.packing_type AS "packingType",
+              i.packing_size AS "packingSize",
+              i.uom AS "uom",
+              coalesce(p.sku, '') AS "productSKU",
+              coalesce(p.name, '') AS "productName",
+              coalesce(p.description, '') AS "productDescription",
+              p.id AS "productId",
+              SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) AS "remainQty",
+              SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) AS "remainUomValue",
+              concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', i.uom) AS "remainUomValueWithUom",
+              'SINGLE' AS "groupType"
+            FROM
+              inventories i
+              LEFT JOIN products p ON i.product_id = p.id
+              LEFT JOIN oi ON i.batch_id = oi.batch_id AND p.name = oi.product_name AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
+              LEFT JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
+              LEFT JOIN (
+                SELECT pbs.product_id, SUM(pbs.bundle_qty * src.release_qty) AS bundle_product_release_qty, SUM(pbs.bundle_qty * src.release_uom_value) AS bundle_product_release_uom_value 
+                FROM product_bundle_settings pbs
+                INNER JOIN json_populate_recordset(NULL::order_inventories,'${batchBundle}') src ON src.product_id = pbs.product_bundle_id
+                GROUP BY pbs.product_id
+              ) bp on i.product_id = bp.product_id
+            WHERE i.domain_id = $1
+            AND l2.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
+            ${productWhereClause}
+            GROUP BY
+            i.batch_id,
+            i.batch_id_ref,
+            p.id,
+            i.packing_type,
+            i.packing_size,
+            i.uom
+            UNION 
+            SELECT 'BUNDLE' AS "batchId", null as "batchIdRef", packing_type, packing_size,'UNIT' AS "uom", sku AS "productSKU", name AS "productName", description AS "productDescription", id AS "productId",
+            MIN(FLOOR(pbs."availableQty")) AS "remainQty", 
+            MIN(FLOOR(pbs."availableUomValue")) AS "remainUomValue", 
+            CONCAT(MIN(FLOOR(pbs."availableUomValue")),' UNIT') AS "remainUomValueWithUom", 
+            'BUNDLE' AS "groupType"
+            FROM product_bundles pb
+            INNER JOIN (
+              SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
+              (SUM(COALESCE(i2.qty, 0)) - SUM(COALESCE(i2.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
+              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue"
+              FROM product_bundle_settings pbs 
+              LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id AND i2.domain_id = $1
+              AND i2.bizplace_id IN (${bizplaceIds})
+              AND i2.status = 'STORED'
+              LEFT JOIN oi ON oi.product_id = i2.product_id
+              GROUP BY pbs.product_id, pbs.product_bundle_id
+            ) pbs ON pbs.product_bundle_id = pb.id
+            ${bundleWhereClause}
+            GROUP BY pb.packing_type, pb.packing_size, pb.name, pb.sku, pb.id
+          )
+          AS inv_prod_grp
+          ${whereClause}
+        )
+      `
+
+    let filterGroupTypeQuery
+
+    if (_groupType) {
+      if (_groupType.value === 'SINGLE') {
+        filterGroupTypeQuery = `where "groupType"= 'SINGLE' `
+      } else {
+        filterGroupTypeQuery = `where "groupType"= 'BUNDLE' `
+      }
+    }
+
+    await trxMgr.query(queryStrings, [domain.id])
+
+    const [{ total }]: any = await trxMgr.query(
+      `select count(*) as total from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''}`
+    )
+    let items: any[] = []
+
+    if (params?.pagination) {
+      items = await trxMgr.query(
+        `select * from temp_inventory_product_group  ${
+          filterGroupTypeQuery ? filterGroupTypeQuery : ''
+        } OFFSET $1 LIMIT $2`,
+        [(params.pagination.page - 1) * params.pagination.limit, params.pagination.limit]
+      )
+    } else {
+      items = await trxMgr.query(
+        `select * from temp_inventory_product_group ${filterGroupTypeQuery ? filterGroupTypeQuery : ''}
+        }`
+      )
+    }
+
+    await trxMgr.query(`drop table temp_inventory_product_group`)
+
+    return { items, total }
+  } catch (error) {
+    throw error
+  }
+}
+
+async function getConditions(
+  bizplaces: Bizplace[],
+  filters: [{ name: string; operator: string; value: any }],
+  hasRemainingQty: Boolean = true
+) {
+  let bizplaceIds = bizplaces.map((bizplace: Bizplace) => `'${bizplace.id}'`).join()
+
+  let productWhereClause = `
+    AND i.status = 'STORED'
+    AND i.bizplace_id IN (${bizplaceIds})
+  `
+
+  let bundleWhereClause = `
+    WHERE pb.status = 'ACTIVATED'
+  `
+
+  let whereClause = hasRemainingQty ? ` WHERE "remainQty" > 0` : ` WHERE 1 = 1`
+
+  let productDetailWhereClause = ``
+
+  let batchBundle: string
+  if (filters?.length) {
+    await Promise.all(
+      filters.map(async (filter: { name: string; operator: string; value: any }) => {
+        const name = filter.name
+        const operator = filter.operator.toLowerCase()
+        let value = filter.value
+
+        switch (name) {
+          case 'batchId':
+            whereClause += `AND LOWER("batchId") LIKE '${value.toLowerCase()}'`
+            break
+
+          case 'productSKU':
+            whereClause += `AND LOWER("productSKU") LIKE '${value.toLowerCase()}'`
+
+          case 'batch_bundle':
+            bundleWhereClause += `
+              ${bundleWhereClause == '' ? 'WHERE' : 'AND'} pb.id ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
+              .map((v: { productId: string }) => `('${v.productId}')`)
+              .join()})
+            `
+            break
+        }
+      })
+    )
+
+    batchBundle = JSON.stringify(
+      filters
+        .find(filter => filter.name === 'batch_bundle')
+        ?.value.map(itm => {
+          return {
+            product_id: itm.productId,
+            release_qty: itm?.releaseQty || 0,
+            release_uom_value: itm?.releaseUomValue || 0
+          }
+        }) || []
+    )
+  }
+
+  return {
+    bizplaceIds,
+    productWhereClause,
+    bundleWhereClause,
+    whereClause,
+    batchBundle,
+    productDetailWhereClause
+  }
+}

package/server/routers/api/restful-apis/v1/warehouse/get-onhand-inventory-list.ts

@@ -0,0 +1,99 @@
+import { Between, getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { ArrivalNotice } from '@things-factory/sales-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { validateFromToDate, validateLimitOffset } from '../utils/validate-util'
+import _ from 'lodash'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-onhand-inventory-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
+      const { fromDate, toDate } = validateFromToDate(context.query.fromDate, context.query.toDate)
+
+      // get contact points for that bizplace
+      // optional query parameter filter
+      let filter = { ...context.query }
+      filter['bizplace'] = filter['bizplaceId']
+      delete filter['bizplaceId']
+      if (_.has(filter, 'ganNo')) {
+        filter['name'] = filter['ganNo']
+        delete filter['ganNo']
+      }
+      filter['createdAt'] = Between(fromDate, toDate)
+
+      delete filter['fromDate']
+      delete filter['toDate']
+      delete filter['limit']
+      delete filter['offset']
+      const [arrivalNotices, totalCount]: ArrivalNotice[] = await getRepository(ArrivalNotice).findAndCount({
+        where: filter,
+        relations: ['orderProducts', 'orderProducts.product'],
+        skip: offset,
+        take: limit,
+        order: { createdAt: 'DESC' }
+      })
+
+      // create and format data response
+      let data = []
+      for (const arrivalNotice of arrivalNotices) {
+        let orderProducts = []
+        for (const orderProduct of arrivalNotice.orderProducts) {
+          const orderProductsDataPoint = {
+            product: {
+              sku: orderProduct.product.sku,
+              uom: orderProduct.product.uom,
+              uomValue: orderProduct.product.uomValue
+            },
+            batchId: orderProduct.batchId,
+            packingType: orderProduct.packingType,
+            packingSize: orderProduct.packingSize,
+            packQty: orderProduct.packQty,
+            palletQty: orderProduct.palletQty
+          }
+          orderProducts.push(orderProductsDataPoint)
+        }
+        const datapoint = {
+          id: arrivalNotice.id,
+          ganNo: arrivalNotice.ganNo,
+          refNo: arrivalNotice.refNo,
+          refNo2: arrivalNotice.refNo2,
+          refNo3: arrivalNotice.refNo3,
+          etaDate: arrivalNotice.etaDate,
+          ownTransport: arrivalNotice.ownTransport,
+          importCargo: arrivalNotice.importCargo,
+          container: arrivalNotice.container,
+          truckNo: arrivalNotice.truckNo,
+          deliveryOrderNo: arrivalNotice.deliveryOrderNo,
+          containerNo: arrivalNotice.containerNo,
+          containerSize: arrivalNotice.containerSize,
+          orderProducts,
+          supplier: {
+            name: arrivalNotice?.supplier?.name || null,
+            companyName: arrivalNotice?.supplier?.companyName || null,
+            email: arrivalNotice?.supplier?.email || null,
+            accountNo: arrivalNotice?.supplier?.accountNo || null
+          }
+        }
+        data.push(datapoint)
+      }
+
+      context.body = {
+        data,
+        totalCount,
+        limit,
+        offset
+      }
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/warehouse/get-release-order-details.ts

@@ -0,0 +1,97 @@
+import { getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { ReleaseGood } from '@things-factory/sales-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import _ from 'lodash'
+import { businessMiddleware, validationMiddleware, loggingMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-release-order-details',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      // get contact points for that bizplace
+      // optional query parameter filter
+      let filter = { ...context.query }
+      filter['bizplace'] = filter['bizplaceId']
+      delete filter['bizplaceId']
+      if (_.has(filter, 'roNo')) {
+        filter['name'] = filter['roNo']
+        delete filter['roNo']
+      }
+
+      const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+        where: filter,
+        relations: ['orderInventories', 'orderInventories.product']
+      })
+
+      // create and format data response
+      let orderInventories = []
+      for (const orderInventory of releaseGood.orderInventories) {
+        const orderInventoriesDataPoint = {
+          product: {
+            sku: orderInventory.product.sku,
+            refCode: orderInventory.product.refCode
+          },
+          batchId: orderInventory.batchId,
+          packingType: orderInventory.packingType,
+          releaseQty: orderInventory.releaseQty,
+          packingSize: orderInventory.packingSize
+        }
+        orderInventories.push(orderInventoriesDataPoint)
+      }
+      const data = {
+        id: releaseGood.id,
+        roNo: releaseGood.roNo,
+        refNo: releaseGood.refNo,
+        refNo2: releaseGood.refNo2,
+        refNo3: releaseGood.refNo3,
+        type: releaseGood.type,
+        releaseDate: releaseGood.releaseDate,
+        collectionOrderNo: releaseGood.collectionOrderNo,
+        ownTransport: releaseGood.ownTransport,
+        exportOption: releaseGood.exportOption,
+        transporter: releaseGood.transporter,
+        trackingNo: releaseGood.trackingNo,
+        marketplaceOrderStatus: releaseGood.marketplaceOrderStatus,
+        airwayBill: releaseGood.airwayBill,
+        invoice: releaseGood.invoice,
+        storeName: releaseGood.storeName,
+        storeId: releaseGood.storeId,
+        routeId: releaseGood.routeId,
+        stopId: releaseGood.stopId,
+        billTo: {
+          billingAddress: releaseGood.billingAddress
+        },
+        deliverTo: {
+          deliveryAddress1: releaseGood.deliveryAddress1,
+          deliveryAddress2: releaseGood.deliveryAddress2,
+          deliveryAddress3: releaseGood.deliveryAddress3,
+          deliveryAddress4: releaseGood.deliveryAddress4,
+          deliveryAddress5: releaseGood.deliveryAddress5,
+          attentionTo: releaseGood.attentionTo,
+          attentionCompany: releaseGood.attentionCompany,
+          city: releaseGood.city,
+          state: releaseGood.state,
+          postalCode: releaseGood.postalCode,
+          country: releaseGood.country,
+          phone1: releaseGood.phone1,
+          phone2: releaseGood.phone2,
+          email: releaseGood.email
+        },
+        orderInventories
+      }
+
+      context.body = {
+        data
+      }
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/warehouse/get-release-order-list.ts

@@ -0,0 +1,116 @@
+import _ from 'lodash'
+import { Between, getRepository } from 'typeorm'
+
+import { restfulApiRouter as router } from '@things-factory/api'
+import { ReleaseGood } from '@things-factory/sales-base'
+
+import { ApiError, ApiErrorHandler, throwInternalServerError } from '../utils/error-util'
+import { validateFromToDate, validateLimitOffset } from '../utils/validate-util'
+import { businessMiddleware, loggingMiddleware, validationMiddleware } from '../middlewares'
+
+router.get(
+  '/v1/warehouse/get-release-order-list',
+  businessMiddleware,
+  validationMiddleware,
+  loggingMiddleware,
+  async (context, next) => {
+    try {
+      const { limit, offset } = validateLimitOffset(context.query.limit, context.query.offset)
+      const { fromDate, toDate } = validateFromToDate(context.query.fromDate, context.query.toDate)
+
+      // get contact points for that bizplace
+      // optional query parameter filter
+      let filter = { ...context.query }
+      filter['bizplace'] = filter['bizplaceId']
+      delete filter['bizplaceId']
+      if (_.has(filter, 'roNo')) {
+        filter['name'] = filter['roNo']
+        delete filter['roNo']
+      }
+      filter['createdAt'] = Between(fromDate, toDate)
+
+      delete filter['fromDate']
+      delete filter['toDate']
+      delete filter['limit']
+      delete filter['offset']
+
+      const [releaseGoods, totalCount]: ReleaseGood[] = await getRepository(ReleaseGood).findAndCount({
+        where: filter,
+        relations: ['orderInventories', 'orderInventories.product'],
+        skip: offset,
+        take: limit,
+        order: { createdAt: 'DESC' }
+      })
+
+      // create and format data response
+      let data = []
+      for (const releaseGood of releaseGoods) {
+        let orderInventories = []
+        for (const orderInventory of releaseGood.orderInventories) {
+          const orderInventoriesDataPoint = {
+            product: {
+              sku: orderInventory.product.sku,
+              refCode: orderInventory.product.refCode
+            },
+            batchId: orderInventory.batchId,
+            packingType: orderInventory.packingType,
+            releaseQty: orderInventory.releaseQty,
+            packingSize: orderInventory.packingSize
+          }
+          orderInventories.push(orderInventoriesDataPoint)
+        }
+        const datapoint = {
+          id: releaseGood.id,
+          roNo: releaseGood.roNo,
+          refNo: releaseGood.refNo,
+          refNo2: releaseGood.refNo2,
+          refNo3: releaseGood.refNo3,
+          type: releaseGood.type,
+          releaseDate: releaseGood.releaseDate,
+          collectionOrderNo: releaseGood.collectionOrderNo,
+          ownTransport: releaseGood.ownTransport,
+          exportOption: releaseGood.exportOption,
+          transporter: releaseGood.transporter,
+          trackingNo: releaseGood.trackingNo,
+          marketplaceOrderStatus: releaseGood.marketplaceOrderStatus,
+          airwayBill: releaseGood.airwayBill,
+          invoice: releaseGood.invoice,
+          storeName: releaseGood.storeName,
+          storeId: releaseGood.storeId,
+          routeId: releaseGood.routeId,
+          stopId: releaseGood.stopId,
+          billTo: {
+            billingAddress: releaseGood.billingAddress
+          },
+          deliverTo: {
+            deliveryAddress1: releaseGood.deliveryAddress1,
+            deliveryAddress2: releaseGood.deliveryAddress2,
+            deliveryAddress3: releaseGood.deliveryAddress3,
+            deliveryAddress4: releaseGood.deliveryAddress4,
+            deliveryAddress5: releaseGood.deliveryAddress5,
+            attentionTo: releaseGood.attentionTo,
+            attentionCompany: releaseGood.attentionCompany,
+            city: releaseGood.city,
+            state: releaseGood.state,
+            postalCode: releaseGood.postalCode,
+            country: releaseGood.country,
+            phone1: releaseGood.phone1,
+            phone2: releaseGood.phone2,
+            email: releaseGood.email
+          },
+          orderInventories
+        }
+        data.push(datapoint)
+      }
+      context.body = {
+        data,
+        totalCount,
+        limit,
+        offset
+      }
+    } catch (e) {
+      if (e instanceof ApiError) ApiErrorHandler(context, e)
+      else throwInternalServerError(context, e)
+    }
+  }
+)

package/server/routers/api/restful-apis/v1/warehouse/index.ts

@@ -0,0 +1,10 @@
+import './cancel-inbound-order'
+import './get-delivery-order-list'
+import './get-goods-received-note-list'
+import './get-inbound-order-details'
+import './get-inbound-order-list'
+import './get-inventory-product-group-list'
+import './get-onhand-inventory-list'
+import './get-release-order-details'
+import './get-release-order-list'
+import './add-release-order'

package/dist-server/routers/api/restful-apis/v1/bizplace.js

@@ -1,45 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const graphql_tag_1 = __importDefault(require("graphql-tag"));
-const api_1 = require("@things-factory/api");
-const debug = require('debug')('things-factory:operato-hub:restful-api:v1:bizplace');
-api_1.restfulApiRouter.get('/v1/bizplace/:id', async (context, next) => {
-    const { client } = context.state;
-    const { id } = context.params;
-    debug('params', context.params);
-    context.body = {
-        result: (await client.query({
-            query: (0, graphql_tag_1.default) `
-          query bizplace($id: String!) {
-            bizplace(id: $id) {
-              id
-              name
-              description
-              address
-              postalCode
-              latlng
-              status
-              creator {
-                name
-                email
-              }
-              updater {
-                name
-                email
-              }
-              createdAt
-              updatedAt
-            }
-          }
-        `,
-            variables: {
-                id
-            },
-            context
-        })).data
-    };
-});
-//# sourceMappingURL=bizplace.js.map

package/dist-server/routers/api/restful-apis/v1/bizplace.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bizplace.js","sourceRoot":"","sources":["../../../../../server/routers/api/restful-apis/v1/bizplace.ts"],"names":[],"mappings":";;;;;AAAA,8DAA6B;AAC7B,6CAAgE;AAEhE,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,oDAAoD,CAAC,CAAA;AAEpF,sBAAM,CAAC,GAAG,CAAC,kBAAkB,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;IACrD,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAA;IAChC,MAAM,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,CAAA;IAE7B,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;IAE/B,OAAO,CAAC,IAAI,GAAG;QACb,MAAM,EAAE,CACN,MAAM,MAAM,CAAC,KAAK,CAAC;YACjB,KAAK,EAAE,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;SAsBT;YACD,SAAS,EAAE;gBACT,EAAE;aACH;YACD,OAAO;SACD,CAAC,CACV,CAAC,IAAI;KACP,CAAA;AACH,CAAC,CAAC,CAAA"}