@things-factory/product-base 8.0.0-beta.9 → 8.0.0

package/server/service/product-bundle-setting/product-bundle-setting-query.ts

@@ -0,0 +1,139 @@
+import { Args, Ctx, Query, Resolver } from 'type-graphql'
+import { Brackets, SelectQueryBuilder } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { buildCondition, buildQuery, convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Product } from '../product/product'
+import { ProductBundleSetting } from './product-bundle-setting'
+import { ProductBundleSettingList } from './product-bundle-setting-types'
+
+@Resolver(ProductBundleSetting)
+export class ProductBundleSettingQuery {
+  @Query(returns => ProductBundleSettingList)
+  async productBundleSettings(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductBundleSettingList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(ProductBundleSetting).findAndCount({
+      ...convertedParams
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => ProductBundleSettingList)
+  async productBundleSets(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductBundleSettingList> {
+    const { domain } = context.state
+    const page = params.pagination.page
+    const limit = params.pagination.limit
+
+    const filters = params.filters.filter(x => x.name !== 'product_info' && x.name !== 'productBundleId')
+    const productBundleId = params.filters.find(x => x.name === 'productBundleId')
+    const productInfoFilter = params.filters.find(x => x.name === 'product_info')
+    const productInfoColumns = ['sku', 'name', 'description']
+    params.filters = [...filters]
+
+    params.sortings = [
+      { name: 'prd.sku' },
+      { name: 'prdDet.gtin' },
+      ...params.sortings.map(sorting => {
+        const name = sorting.name.replace('product', '').toLowerCase()
+        return {
+          ...sorting,
+          name
+        }
+      })
+    ]
+
+    if (!params.filters.find(filter => filter.name === 'bizplace_id')) {
+      let bizplace: Bizplace = await getRepository(Bizplace).findOne({ where: { domain: { id: domain.id } } })
+      params.filters = [...filters, { name: 'bizplace_id', operator: 'in', value: [bizplace.id] }]
+    }
+
+    const qb: SelectQueryBuilder<Product> = getRepository(Product).createQueryBuilder('prd')
+    buildQuery(qb, params, context)
+
+    qb.innerJoinAndSelect('product_details', 'prdDet', 'prdDet.product_id = prd.id')
+    qb.leftJoinAndSelect(
+      'product_bundle_settings',
+      'pbs',
+      'pbs.product_id = prd.id and pbs.product_detail_id = prdDet.id'
+    )
+    qb.leftJoinAndSelect('pbs.productBundle', 'pb')
+
+    if (productInfoFilter) {
+      qb.andWhere(
+        new Brackets(qb2 => {
+          productInfoColumns.forEach(filter => {
+            const condition = buildCondition(
+              qb.alias,
+              filter,
+              productInfoFilter.operator,
+              productInfoFilter.value,
+              productInfoFilter.relation,
+              Object.keys(qb.getParameters()).length
+            )
+
+            qb2.orWhere(condition.clause, condition.parameters)
+          })
+        })
+      )
+    }
+
+    if (productBundleId && productBundleId.operator === 'eq') {
+      qb.andWhere('pb.id = :bundleId::uuid', {
+        bundleId: productBundleId.value
+      })
+    }
+
+    let productBundleSets = await qb
+      .offset((page - 1) * limit)
+      .limit(limit)
+      .getRawMany()
+
+    const items = productBundleSets.map(item => {
+      return {
+        // id: item.pbs_id,
+        // productDetailId: item.prdDet_id,
+        // gtin: item.prdDet_gtin,
+        // packingType: item.prdDet_packing_type,
+        // packingSize: item.prdDet_packing_size,
+        // productId: item.prd_id,
+        // productSku: item.prd_sku,
+        // productName: item.prd_name,
+        // productDescription: item.prd_description,
+        // productType: item.prd_type,
+        // bundleId: item.pb_id,
+        // bundleSku: item.pb_sku,
+        // bundleName: item.pb_name,
+        // bundleDescription: item.pb_description,
+        // bundleQty: item.pbs_bundle_qty
+        ...item,
+        id: item.pbs_id,
+        product: {
+          id: item.prd_id,
+          sku: item.prd_sku,
+          name: item.prd_name,
+          description: item.prd_description,
+          type: item.prd_type
+        },
+        productDetail: {
+          id: item.prdDet_id,
+          gtin: item.prdDet_gtin,
+          packingType: item.prdDet_packing_type,
+          packingSize: item.prdDet_packing_size
+        },
+        bundleQty: item.pbs_bundle_qty
+      }
+    })
+
+    const total = await qb.getCount()
+
+    return { items, total }
+  }
+}

package/server/service/product-bundle-setting/product-bundle-setting-types.ts

@@ -0,0 +1,41 @@
+import { Field, Float, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ProductBundleSetting } from './product-bundle-setting'
+
+@ObjectType()
+export class ProductBundleSettingList {
+  @Field(type => [ProductBundleSetting], { nullable: true })
+  items?: ProductBundleSetting[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class ProductBundleSettingPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  product?: ObjectRef
+
+  @Field({ nullable: true })
+  productDetail?: ObjectRef
+
+  @Field({ nullable: true })
+  productBundle?: ObjectRef
+
+  @Field(type => Int, { nullable: true })
+  bundleQty?: number
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}

package/server/service/product-bundle-setting/product-bundle-setting.ts

@@ -0,0 +1,45 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
+
+import { ProductBundle } from '../product-bundle/product-bundle'
+import { ProductDetail } from '../product-detail/product-detail'
+import { Product } from '../product/product'
+
+@Entity()
+@Index(
+  'ix_product_bundle_setting_0',
+  (productBundleSetting: ProductBundleSetting) => [
+    productBundleSetting.product,
+    productBundleSetting.productDetail,
+    productBundleSetting.productBundle
+  ],
+  { unique: true }
+)
+@ObjectType()
+export class ProductBundleSetting {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { nullable: true })
+  readonly id?: string
+
+  @ManyToOne(type => Product, { nullable: true })
+  @Field(type => Product, { nullable: true })
+  product?: Product
+
+  @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field(type => ProductDetail, { nullable: true })
+  productDetail?: ProductDetail
+
+  @ManyToOne(type => ProductBundle, { nullable: true })
+  @Field(type => ProductBundle, { nullable: true })
+  productBundle?: ProductBundle
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  bundleQty?: number
+
+  @Field({ nullable: true })
+  productId?: string
+
+  @Field({ nullable: true })
+  bundleId?: string
+}

package/server/service/product-combination/index.ts

@@ -0,0 +1,6 @@
+import { ProductCombination } from './product-combination'
+import { ProductCombinationQuery } from './product-combination-query'
+import { ProductCombinationMutation } from './product-combination-mutation'
+
+export const entities = [ProductCombination]
+export const resolvers = [ProductCombinationQuery, ProductCombinationMutation]

package/server/service/product-combination/product-combination-mutation.ts

@@ -0,0 +1,148 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In, Repository } from 'typeorm'
+
+import { ProductDetail } from '../product-detail/product-detail'
+import { ProductCombination, ProductCombinationStatus } from './product-combination'
+import { NewProductCombination, ProductCombinationPatch } from './product-combination-type'
+
+@Resolver(ProductCombination)
+export class ProductCombinationMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ProductCombination, { description: 'To create new ProductCombination' })
+  async createProductCombination(
+    @Arg('productCombination') productCombination: NewProductCombination,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombination> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(ProductCombination).save({
+      ...productCombination,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ProductCombination, { description: 'To modify ProductCombination information' })
+  async updateProductCombination(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ProductCombinationPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombination> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(ProductCombination)
+    const productCombination = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    return await repository.save({
+      ...productCombination,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [ProductCombination], { description: "To modify multiple ProductCombinations' information" })
+  async updateMultipleProductCombination(
+    @Arg('productDetailId', type => String) productDetailId: string,
+    @Arg('patches', type => [ProductCombinationPatch]) patches: ProductCombinationPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombination[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => !patch.id)
+    const _updateRecords = patches.filter((patch: any) => patch.id)
+    const productDetailRepo = tx.getRepository(ProductDetail)
+    const productCombinationRepo = tx.getRepository(ProductCombination)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        let newRecord = _createRecords[i]
+        const productDetail: ProductDetail = await productDetailRepo.findOne({
+          where: { id: productDetailId },
+          relations: ['product']
+        })
+
+        delete newRecord.id
+
+        if (!newRecord?.status) {
+          newRecord.status = ProductCombinationStatus.INACTIVE
+        }
+
+        const result = await productCombinationRepo.save({
+          ...newRecord,
+          domain,
+          productDetail,
+          product: productDetail.product,
+          status: newRecord.status.toUpperCase(),
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const productCombination = await productCombinationRepo.findOneBy({
+          domain: { id: domain.id },
+          id: newRecord.id
+        })
+
+        if (newRecord.status) {
+          newRecord.status = newRecord.status.toUpperCase()
+        }
+
+        const result = await productCombinationRepo.save({
+          ...productCombination,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete ProductCombination' })
+  async deleteProductCombination(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { user, tx } = context.state
+
+    await tx.getRepository(ProductCombination).update({ id }, { deletedAt: new Date(), deletedBy: user })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple productCombinations' })
+  async deleteProductCombinations(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { user, tx } = context.state
+
+    const productCombinationRepo: Repository<ProductCombination> = tx.getRepository(ProductCombination)
+
+    let productCombinations = await productCombinationRepo.find({ where: { id: In(ids) } })
+
+    for (let i = 0; i < productCombinations.length; i++) {
+      const product = productCombinations[i]
+
+      await productCombinationRepo.save({
+        ...product,
+        status: ProductCombinationStatus.DELETED,
+        updater: user
+      })
+    }
+
+    return true
+  }
+}

package/server/service/product-combination/product-combination-query.ts

@@ -0,0 +1,48 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
+
+import { ProductCombination } from './product-combination'
+import { ProductCombinationList } from './product-combination-type'
+
+@Resolver(ProductCombination)
+export class ProductCombinationQuery {
+  @Query(returns => ProductCombination, { description: 'To fetch a ProductCombination' })
+  async productCombination(@Arg('id') name: string, @Ctx() context: ResolverContext): Promise<ProductCombination> {
+    const { domain, tx } = context.state
+
+    return await tx.getRepository(ProductCombination).findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+  }
+
+  @Query(returns => ProductCombinationList, { description: 'To fetch multiple ProductCombinations' })
+  async productCombinations(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ProductCombinationList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(ProductCombination).findAndCount({
+      ...convertedParams,
+      relations: ['product', 'productDetail']
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() productCombination: ProductCombination): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: productCombination.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() productCombination: ProductCombination): Promise<User> {
+    return await getRepository(User).findOneBy({ id: productCombination.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() productCombination: ProductCombination): Promise<User> {
+    return await getRepository(User).findOneBy({ id: productCombination.creatorId })
+  }
+}

package/server/service/product-combination/product-combination-type.ts

@@ -0,0 +1,50 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ProductCombination, ProductCombinationStatus } from './product-combination'
+
+@InputType()
+export class NewProductCombination {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ProductCombinationStatus, { nullable: true })
+  status?: string
+}
+
+@InputType()
+export class ProductCombinationPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  product?: ObjectRef
+
+  @Field({ nullable: true })
+  productDetail?: ObjectRef
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ProductCombinationList {
+  @Field(type => [ProductCombination])
+  items: ProductCombination[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/product-combination/product-combination.ts

@@ -0,0 +1,116 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ProductCombinationSetting } from '../product-combination-setting/product-combination-setting'
+import { ProductDetail } from '../product-detail/product-detail'
+import { Product } from '../product/product'
+
+export enum ProductCombinationStatus {
+  ACTIVE = 'ACTIVE',
+  ACTIVATED = 'ACTIVATED',
+  DELETED = 'DELETED',
+  INACTIVE = 'INACTIVE'
+}
+
+registerEnumType(ProductCombinationStatus, {
+  name: 'ProductCombinationStatus',
+  description: 'status enumeration of a productCombination'
+})
+
+@Entity()
+@Index(
+  'ix_product_combination_0',
+  (productCombination: ProductCombination) => [productCombination.domain, productCombination.id],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for ProductCombination' })
+export class ProductCombination {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((productCombination: ProductCombination) => productCombination.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @OneToMany(
+    type => ProductCombinationSetting,
+    productCombinationSetting => productCombinationSetting.productCombination
+  )
+  @Field(type => [ProductCombinationSetting], { nullable: true })
+  productCombinationSettings?: ProductCombinationSetting[]
+
+  @ManyToOne(type => Product)
+  @Field(type => Product)
+  product?: Product
+
+  @RelationId((productCombination: ProductCombination) => productCombination.product)
+  productId?: string
+
+  @ManyToOne(type => ProductDetail, { nullable: false })
+  @Field(type => ProductDetail)
+  productDetail?: ProductDetail
+
+  @RelationId((productCombination: ProductCombination) => productCombination.productDetail)
+  productDetailId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  deletedAt: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  deletedBy: User
+
+  @RelationId((productCombination: ProductCombination) => productCombination.deletedBy)
+  deletedById?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((productCombination: ProductCombination) => productCombination.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((productCombination: ProductCombination) => productCombination.updater)
+  updaterId?: string
+}

package/server/service/product-combination-setting/index.ts

@@ -0,0 +1,6 @@
+import { ProductCombinationSetting } from './product-combination-setting'
+import { ProductCombinationSettingQuery } from './product-combination-setting-query'
+import { ProductCombinationSettingMutation } from './product-combination-setting-mutation'
+
+export const entities = [ProductCombinationSetting]
+export const resolvers = [ProductCombinationSettingQuery, ProductCombinationSettingMutation]