@things-factory/product-base 8.0.0-beta.0 → 8.0.0-beta.2

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

@@ -1,139 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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]