@things-factory/biz-base 8.0.0-beta.8 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/biz-base",
-  "version": "8.0.0-beta.8",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,7 +24,7 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^8.0.0-beta.8"
+    "@things-factory/auth-base": "^8.0.0"
   },
-  "gitHead": "bf5206511b2d84dfb95edc3dae7f54f6cbb9bcca"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/index.ts

@@ -0,0 +1,3 @@
+export * from './service'
+export * from './migrations'
+export * from './utils'

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})

package/server/service/biz-option/biz-option-mutation.ts

@@ -0,0 +1,65 @@
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { BizOption } from './biz-option'
+import { BizOptionPatch, NewBizOption } from './biz-option-types'
+
+@Resolver(BizOption)
+export class BizOptionMutation {
+  @Mutation(returns => BizOption)
+  async createBizOption(
+    @Arg('bizOption') bizOption: NewBizOption,
+    @Ctx() context: ResolverContext
+  ): Promise<BizOption> {
+    const { domain, user } = context.state
+
+    return await getRepository(BizOption).save({
+      ...bizOption,
+      domain: domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Mutation(returns => BizOption)
+  async updateBizOption(
+    @Arg('name') name: string,
+    @Arg('patch') patch: BizOptionPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<BizOption> {
+    const { domain, user } = context.state
+
+    const repository = getRepository(BizOption)
+    const bizOption = await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    return await repository.save({
+      ...bizOption,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteBizOption(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain } = context.state
+
+    await getRepository(BizOption).delete({ domain: { id: domain.id }, name })
+    return true
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteBizOptions(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    await getRepository(BizOption).delete({
+      domain: { id: context.state.domain.id },
+      name: In(names)
+    })
+    return true
+  }
+}

package/server/service/biz-option/biz-option-query.ts

@@ -0,0 +1,30 @@
+import { Arg, Args, Ctx, Query, Resolver } from 'type-graphql'
+
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { BizOption } from './biz-option'
+import { BizOptionList } from './biz-option-types'
+
+@Resolver(BizOption)
+export class BizOptionQuery {
+  @Query(returns => BizOption)
+  async bizOption(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<BizOption> {
+    return await getRepository(BizOption).findOne({
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'bizplace', 'bizOptionDetails', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => BizOptionList)
+  async bizOptions(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<BizOptionList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(BizOption).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizplace', 'bizOptionDetails', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+}

package/server/service/biz-option/biz-option-types.ts

@@ -0,0 +1,44 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { BizOption } from './biz-option'
+
+@ObjectType()
+export class BizOptionList {
+  @Field(type => [BizOption], { nullable: true })
+  items?: BizOption[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class BizOptionPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace?: ObjectRef
+
+  @Field(type => [ObjectRef], { nullable: true })
+  bizOptionDetails?: ObjectRef[]
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@InputType()
+export class NewBizOption {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+}

package/server/service/biz-option/biz-option.ts

@@ -0,0 +1,70 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { BizOptionDetail } from '../biz-option-detail/biz-option-detail'
+import { Bizplace } from '../bizplace/bizplace'
+
+@Entity()
+@Index('ix_biz-option_0', (bizOption: BizOption) => [bizOption.bizplace, bizOption.name], { unique: true })
+@ObjectType()
+export class BizOption {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  id: string
+
+  @ManyToOne(type => Domain, { nullable: true })
+  @Field({ nullable: true })
+  domain: Domain
+
+  @Column()
+  @Field()
+  name: string
+
+  @ManyToOne(type => Bizplace, {
+    nullable: false
+  })
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @OneToMany(type => BizOptionDetail, bizOptionDetail => bizOptionDetail.bizOption)
+  @Field(type => BizOptionDetail, { nullable: true })
+  bizOptionDetails: BizOptionDetail[]
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater: User
+}

package/server/service/biz-option/index.ts

@@ -0,0 +1,6 @@
+import { BizOption } from './biz-option'
+import { BizOptionMutation } from './biz-option-mutation'
+import { BizOptionQuery } from './biz-option-query'
+
+export const entities = [BizOption]
+export const resolvers = [BizOptionQuery, BizOptionMutation]

package/server/service/biz-option-detail/biz-option-detail-mutation.ts

@@ -0,0 +1,59 @@
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { BizOptionDetail } from './biz-option-detail'
+import { BizOptionDetailPatch, NewBizOptionDetail } from './biz-option-detail-types'
+
+@Resolver(BizOptionDetail)
+export class BizOptionDetailMutation {
+  @Mutation(returns => BizOptionDetail)
+  async createBizOptionDetail(
+    @Arg('bizOptionDetail') bizOptionDetail: NewBizOptionDetail,
+    @Ctx() context: ResolverContext
+  ): Promise<BizOptionDetail> {
+    return await getRepository(BizOptionDetail).save({
+      ...bizOptionDetail,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+
+  @Mutation(returns => BizOptionDetail)
+  async updateBizOptionDetail(
+    @Arg('name') name: string,
+    @Arg('patch') patch: BizOptionDetailPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<BizOptionDetail> {
+    const repository = getRepository(BizOptionDetail)
+    const bizOptionDetail = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, name }
+    })
+
+    return await repository.save({
+      ...bizOptionDetail,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteBizOptionDetail(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    await getRepository(BizOptionDetail).delete({ domain: { id: context.state.domain.id }, name })
+    return true
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteBizOptionDetails(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    await getRepository(BizOptionDetail).delete({
+      domain: { id: context.state.domain.id },
+      name: In(names)
+    })
+    return true
+  }
+}

package/server/service/biz-option-detail/biz-option-detail-query.ts

@@ -0,0 +1,27 @@
+import { Arg, Args, Ctx, Query, Resolver } from 'type-graphql'
+
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { BizOptionDetail } from './biz-option-detail'
+import { BizOptionDetailList } from './biz-option-detail-types'
+
+@Resolver(BizOptionDetail)
+export class BizOptionDetailQuery {
+  @Query(returns => BizOptionDetail)
+  async bizOptionDetail(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<BizOptionDetail> {
+    return await getRepository(BizOptionDetail).findOne({
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'bizOption', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => BizOptionDetailList)
+  async bizOptionDetails(@Args(type => ListParam) params: ListParam): Promise<BizOptionDetailList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(BizOptionDetail).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizOption', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+}

package/server/service/biz-option-detail/biz-option-detail-types.ts

@@ -0,0 +1,38 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { BizOptionDetail } from './biz-option-detail'
+
+@ObjectType()
+export class BizOptionDetailList {
+  @Field(type => [BizOptionDetail], { nullable: true })
+  items?: BizOptionDetail[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class NewBizOptionDetail {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@InputType()
+export class BizOptionDetailPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  bizOption?: ObjectRef
+}

package/server/service/biz-option-detail/biz-option-detail.ts

@@ -0,0 +1,62 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { BizOption } from '../biz-option/biz-option'
+
+@Entity()
+@Index(
+  'ix_biz-option-detail_0',
+  (bizOptionDetail: BizOptionDetail) => [bizOptionDetail.bizOption, bizOptionDetail.name],
+  {
+    unique: true
+  }
+)
+@ObjectType()
+export class BizOptionDetail {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  id: string
+
+  @ManyToOne(type => Domain, { nullable: true })
+  @Field({ nullable: true })
+  domain: Domain
+
+  @Column()
+  @Field()
+  name: string
+
+  @ManyToOne(type => BizOption, bizOption => bizOption.bizOptionDetails, {
+    nullable: false
+  })
+  @Field(type => BizOption, { nullable: true })
+  bizOption: BizOption
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater: User
+}

package/server/service/biz-option-detail/index.ts

@@ -0,0 +1,6 @@
+import { BizOptionDetail } from './biz-option-detail'
+import { BizOptionDetailMutation } from './biz-option-detail-mutation'
+import { BizOptionDetailQuery } from './biz-option-detail-query'
+
+export const entities = [BizOptionDetail]
+export const resolvers = [BizOptionDetailQuery, BizOptionDetailMutation]

package/server/service/bizplace/bizplace-mutation.ts

@@ -0,0 +1,144 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+
+import { Domain, getRepository } from '@things-factory/shell'
+import { slugger } from '@things-factory/utils'
+
+import { Company } from '../company/company'
+import { Bizplace } from './bizplace'
+import { BizplacePatch, NewBizplace } from './bizplace-types'
+
+@Resolver(Bizplace)
+export class BizplaceMutation {
+  @Directive('@privilege(category: "bizplace", privilege: "mutation")')
+  @Mutation(returns => Bizplace)
+  async createBizplace(@Arg('bizplace') bizplace: NewBizplace, @Ctx() context: ResolverContext): Promise<Bizplace> {
+    const { domain, user } = context.state
+    if (bizplace.company && bizplace.company.id) {
+      bizplace.company = await getRepository(Company).findOneBy({ id: bizplace.company.id })
+    }
+
+    return await getRepository(Bizplace).save({
+      ...bizplace,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "bizplace", privilege: "mutation")')
+  @Mutation(returns => Bizplace)
+  async updateBizplace(
+    @Arg('name') name: string,
+    @Arg('patch') patch: BizplacePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Bizplace> {
+    const { domain, user } = context.state
+    const bizplace = await getRepository(Bizplace).findOneBy({ domain: { id: domain.id }, name })
+
+    if (patch.company && patch.company.id) {
+      patch.company = await getRepository(Company).findOneBy({ id: patch.company.id })
+    }
+
+    return await getRepository(Bizplace).save({
+      ...bizplace,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "bizplace", privilege: "mutation")')
+  @Mutation(returns => [Bizplace])
+  async updateMultipleBizplace(
+    @Arg('patches', type => [BizplacePatch]) patches: BizplacePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Bizplace[]> {
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const bizplaceRepo = getRepository(Bizplace)
+    const companyRepo = getRepository(Company)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        if (newRecord.company && newRecord.company.id) {
+          newRecord.company = await companyRepo.findOneBy({ id: newRecord.company.id })
+        }
+
+        const result = await bizplaceRepo.save({
+          domain: context.state.domain,
+          creator: context.state.user,
+          updater: context.state.user,
+          ...newRecord
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const bizplace = await bizplaceRepo.findOneBy({ id: newRecord.id })
+
+        if (newRecord.company && newRecord.company.id) {
+          newRecord.company = await companyRepo.findOneBy({ id: newRecord.company.id })
+        }
+
+        const result = await bizplaceRepo.save({
+          ...bizplace,
+          ...newRecord,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "bizplace", privilege: "mutation")')
+  @Mutation(returns => Bizplace)
+  async updateBizplaceCheckDomain(
+    @Arg('name') name: string,
+    @Arg('patch') patch: BizplacePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Bizplace> {
+    let bizplace: Bizplace = await getRepository(Bizplace).findOne({ where: { name }, relations: ['domain'] })
+    let domain: Domain = bizplace.domain
+
+    if (domain) {
+      if (bizplace.name !== patch.name) {
+        domain = await getRepository(Domain).save({
+          ...domain,
+          name: patch.name,
+          subdomain: slugger(patch.name)
+        })
+      }
+    }
+
+    return await getRepository(Bizplace).save({
+      ...bizplace,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+
+  @Directive('@privilege(category: "bizplace", privilege: "mutation")')
+  @Mutation(returns => Boolean)
+  async deleteBizplace(@Arg('id') id: string): Promise<Boolean> {
+    await getRepository(Bizplace).delete(id)
+
+    return true
+  }
+
+  @Directive('@privilege(category: "bizplace", privilege: "mutation")')
+  @Mutation(returns => Boolean)
+  async deleteBizplaces(@Arg('ids', type => [String]) ids: string[]): Promise<Boolean> {
+    await getRepository(Bizplace).delete(ids)
+
+    return true
+  }
+}