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

package/server/service/menu/menu.ts

@@ -0,0 +1,183 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { Domain } from '@things-factory/shell'
+import { PrivilegeObject, Role, User } from '@things-factory/auth-base'
+
+import { MenuButton } from '../menu-button/menu-button'
+import { MenuColumn } from '../menu-column/menu-column'
+
+@Entity()
+@Index('ix_menu_0', (menu: Menu) => [menu.domain, menu.name, menu.parent, menu.role], { unique: true })
+@Index('ix_menu_1', (menu: Menu) => [menu.domain, menu.parent])
+@Index('ix_menu_2', (menu: Menu) => [menu.domain, menu.category, menu.menuType, menu.rank])
+@ObjectType({ description: 'Entity for Menu' })
+export class Menu {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((menu: Menu) => menu.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @ManyToOne(type => Menu, parent => parent.children, { nullable: true })
+  @Field({ nullable: true })
+  parent?: Menu
+
+  @RelationId((menu: Menu) => menu.parent)
+  parentId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  template?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  menuType?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  category?: string
+
+  @ManyToOne(type => Role, { nullable: true })
+  @Field(type => Role, { nullable: true })
+  role: Role
+
+  @RelationId((menu: Menu) => menu.role)
+  roleId?: string
+
+  @ManyToMany(type => Role)
+  @JoinTable({ name: 'menus_roles' })
+  @Field(type => [Role], { nullable: true })
+  roles?: Role[]
+
+  @Column('int', { nullable: true })
+  @Field({ nullable: true })
+  rank?: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  iconPath?: string
+
+  @Column({ nullable: true, default: false })
+  @Field({ nullable: true })
+  hiddenFlag?: boolean = false
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  routing?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  routingType?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  detailFormId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  detailLayout?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  resourceType?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  resourceId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  resourceName?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  resourceUrl?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  gridSaveUrl?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  idField?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  titleField?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  pagination?: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  itemsProp?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  totalProp?: string
+
+  @Column('int', { nullable: true })
+  @Field({ nullable: true })
+  fixedColumns?: number
+
+  @OneToMany(type => Menu, child => child.parent)
+  @Field(type => [Menu])
+  children?: Menu[]
+
+  @OneToMany(type => MenuButton, menuButton => menuButton.menu)
+  @Field(type => [MenuButton])
+  buttons?: MenuButton[]
+
+  @OneToMany(type => MenuColumn, menuColumn => menuColumn.menu)
+  @Field(type => [MenuColumn])
+  columns?: MenuColumn[]
+
+  @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((menu: Menu) => menu.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((menu: Menu) => menu.updater)
+  updaterId?: string
+}

package/server/service/menu-button/index.ts

@@ -0,0 +1,6 @@
+import { MenuButton } from './menu-button'
+import { MenuButtonQuery } from './menu-button-query'
+import { MenuButtonMutation } from './menu-button-mutation'
+
+export const entities = [MenuButton]
+export const resolvers = [MenuButtonQuery, MenuButtonMutation]

package/server/service/menu-button/menu-button-mutation.ts

@@ -0,0 +1,142 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { Menu } from '../menu/menu'
+import { MenuButton } from './menu-button'
+import { MenuButtonPatch, NewMenuButton } from './menu-button-type'
+
+@Resolver(MenuButton)
+export class MenuButtonMutation {
+  @Directive('@transaction')
+  @Mutation(returns => MenuButton, { description: 'To create new MenuButton' })
+  async createMenuButton(
+    @Arg('menuButton') menuButton: NewMenuButton,
+    @Ctx() context: ResolverContext
+  ): Promise<MenuButton> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(MenuButton).save({
+      ...menuButton,
+      menu: await tx
+        .getRepository(Menu)
+        .findOne({ where: { domain: { id: context.state.domain.id }, id: menuButton.menu } }),
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => MenuButton, { description: 'To modify MenuButton information' })
+  async updateMenuButton(
+    @Arg('id') id: string,
+    @Arg('patch') patch: MenuButtonPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<MenuButton> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(MenuButton)
+    const menuButton = await repository.findOne({
+      where: { domain: { id: domain.id }, id },
+      relations: ['menu']
+    })
+
+    if (patch.menu) {
+      patch.menu = (await tx.getRepository(Menu).findOneBy({ domain: { id: domain.id }, id: patch.menu })) as any
+    }
+
+    return await repository.save({
+      ...menuButton,
+      ...(patch as any),
+      updater: user
+    })
+  }
+
+  // @Directive('@transaction')
+  // @Mutation(returns => [MenuButton], { description: "To modify multiple MenuButtons' information" })
+  // async updateMultipleMenuButton(
+  //   @Arg('patches', type => [MenuButtonPatch]) patches: MenuButtonPatch[],
+  //   @Ctx() context: ResolverContext
+  // ): Promise<MenuButton[]> {
+  //   const { domain, user, tx } = context.state
+
+  //   let results = []
+  //   const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+  //   const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+  //   const menuButtonRepo = tx.getRepository(MenuButton)
+
+  //   if (_createRecords.length > 0) {
+  //     for (let i = 0; i < _createRecords.length; i++) {
+  //       const newRecord = _createRecords[i]
+
+  //       const result = await menuButtonRepo.save({
+  //         ...newRecord,
+  //         domain,
+  //         creator: user,
+  //         updater: user
+  //       })
+
+  //       results.push({ ...result, cuFlag: '+' })
+  //     }
+  //   }
+
+  //   if (_updateRecords.length > 0) {
+  //     for (let i = 0; i < _updateRecords.length; i++) {
+  //       const updateRecord = _updateRecords[i]
+  //       const menuButton = await menuButtonRepo.findOne(updateRecord.id)
+
+  //       const result = await menuButtonRepo.save({
+  //         ...menuButton,
+  //         ...updateRecord,
+  //         updater: user
+  //       })
+
+  //       results.push({ ...result, cuFlag: 'M' })
+  //     }
+  //   }
+
+  //   return results
+  // }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete MenuButton' })
+  async deleteMenuButton(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(MenuButton).delete({ domain: { id: domain.id }, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple MenuButtons' })
+  async deleteMenuButtons(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(MenuButton).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple MenuButtons' })
+  async importMenuButtons(
+    @Arg('menuButtons', type => [MenuButtonPatch]) menuButtons: MenuButtonPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      menuButtons.map(async (menuButton: MenuButtonPatch) => {
+        await tx.getRepository(MenuButton).save({ domain, ...(menuButton as any) })
+      })
+    )
+
+    return true
+  }
+}

package/server/service/menu-button/menu-button-query.ts

@@ -0,0 +1,59 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Menu } from '../menu/menu'
+import { MenuButton } from './menu-button'
+import { MenuButtonList } from './menu-button-type'
+
+@Resolver(MenuButton)
+export class MenuButtonQuery {
+  @Query(returns => MenuButton, { description: 'To fetch a MenuButton' })
+  async menuButton(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<MenuButton> {
+    const { domain } = context.state
+
+    return await getRepository(MenuButton).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => MenuButtonList, { description: 'To fetch multiple MenuButtons' })
+  async menuButtons(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<MenuButtonList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(MenuButton),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Menu)
+  async menu(@Root() menuButton: MenuButton): Promise<Menu> {
+    return menuButton.menu || (await getRepository(Menu).findOneBy({ id: menuButton.menuId }))
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() menuButton: MenuButton): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: menuButton.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() menuButton: MenuButton): Promise<User> {
+    return await getRepository(User).findOneBy({ id: menuButton.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() menuButton: MenuButton): Promise<User> {
+    return await getRepository(User).findOneBy({ id: menuButton.creatorId })
+  }
+}

package/server/service/menu-button/menu-button-type.ts

@@ -0,0 +1,31 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { MenuButton } from './menu-button'
+
+@InputType()
+export class NewMenuButton {
+  @Field() menu: string
+  @Field(type => Int, { nullable: true }) rank?: number
+  @Field({ nullable: true }) style?: string
+  @Field({ nullable: true }) icon?: string
+  @Field() text: string
+  @Field({ nullable: true }) auth?: string
+  @Field({ nullable: true }) logic?: string
+}
+
+@InputType()
+export class MenuButtonPatch {
+  @Field({ nullable: true }) menu?: string
+  @Field(type => Int, { nullable: true }) rank?: number
+  @Field({ nullable: true }) style?: string
+  @Field({ nullable: true }) icon?: string
+  @Field({ nullable: true }) text?: string
+  @Field({ nullable: true }) auth?: string
+  @Field({ nullable: true }) logic?: string
+}
+
+@ObjectType()
+export class MenuButtonList {
+  @Field(type => [MenuButton]) items: MenuButton[]
+  @Field(type => Int) total: number
+}

package/server/service/menu-button/menu-button.ts

@@ -0,0 +1,86 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { Menu } from '../menu/menu'
+
+@Entity()
+@Index('ix_menu_button_0', (menuButton: MenuButton) => [menuButton.menu, menuButton.text], { unique: true })
+@Index('ix_menu_button_1', (menuButton: MenuButton) => [menuButton.menu])
+@ObjectType({ description: 'Entity for MenuButton' })
+export class MenuButton {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((menuButton: MenuButton) => menuButton.domain)
+  domainId?: string
+
+  @ManyToOne(type => Menu, menu => menu.buttons)
+  @Field(type => Menu, { nullable: true })
+  menu?: Menu
+
+  @RelationId((menuButton: MenuButton) => menuButton.menu)
+  menuId?: string
+
+  @Column('int', { nullable: true })
+  @Field({ nullable: true })
+  rank?: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  style?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  icon?: string
+
+  @Column()
+  @Field({ nullable: true })
+  text?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  auth?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  logic?: 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((menuButton: MenuButton) => menuButton.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((menuButton: MenuButton) => menuButton.updater)
+  updaterId?: string
+}

package/server/service/menu-column/index.ts

@@ -0,0 +1,6 @@
+import { MenuColumn } from './menu-column'
+import { MenuColumnQuery } from './menu-column-query'
+import { MenuColumnMutation } from './menu-column-mutation'
+
+export const entities = [MenuColumn]
+export const resolvers = [MenuColumnQuery, MenuColumnMutation]

package/server/service/menu-column/menu-column-mutation.ts

@@ -0,0 +1,143 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { Menu } from '../menu/menu'
+import { MenuColumn } from './menu-column'
+import { MenuColumnPatch, NewMenuColumn } from './menu-column-type'
+
+@Resolver(MenuColumn)
+export class MenuColumnMutation {
+  @Directive('@transaction')
+  @Mutation(returns => MenuColumn, { description: 'To create new MenuColumn' })
+  async createMenuColumn(
+    @Arg('menuColumn') menuColumn: NewMenuColumn,
+    @Ctx() context: ResolverContext
+  ): Promise<MenuColumn> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(MenuColumn).save({
+      ...menuColumn,
+      menu: await tx.getRepository(Menu).findOne({ where: { domain: { id: domain.id }, name: menuColumn.menu } }),
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => MenuColumn, { description: 'To modify MenuColumn information' })
+  async updateMenuColumn(
+    @Arg('id') id: string,
+    @Arg('patch') patch: MenuColumnPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<MenuColumn> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(MenuColumn)
+
+    const menuColumn = await repository.findOne({
+      where: { domain: { id: domain.id }, id },
+      relations: ['menu']
+    })
+
+    if (patch.menu) {
+      patch.menu = (await tx.getRepository(Menu).findOne({
+        where: { domain: { id: domain.id }, id: patch.menu }
+      })) as any
+    }
+
+    return await repository.save({
+      ...menuColumn,
+      ...(patch as any),
+      updater: user
+    })
+  }
+
+  // @Directive('@transaction')
+  // @Mutation(returns => [MenuColumn], { description: "To modify multiple MenuColumns' information" })
+  // async updateMultipleMenuColumn(
+  //   @Arg('patches', type => [MenuColumnPatch]) patches: MenuColumnPatch[],
+  //   @Ctx() context: ResolverContext
+  // ): Promise<MenuColumn[]> {
+  //   const { domain, user, tx } = context.state
+
+  //   let results = []
+  //   const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+  //   const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+  //   const menuColumnRepo = tx.getRepository(MenuColumn)
+
+  //   if (_createRecords.length > 0) {
+  //     for (let i = 0; i < _createRecords.length; i++) {
+  //       const newRecord = _createRecords[i]
+
+  //       const result = await menuColumnRepo.save({
+  //         ...newRecord,
+  //         domain,
+  //         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 menuColumn = await menuColumnRepo.findOneBy({ id: newRecord.id })
+
+  //       const result = await menuColumnRepo.save({
+  //         ...menuColumn,
+  //         ...newRecord,
+  //         updater: user
+  //       })
+
+  //       results.push({ ...result, cuFlag: 'M' })
+  //     }
+  //   }
+
+  //   return results
+  // }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete MenuColumn' })
+  async deleteMenuColumn(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(MenuColumn).delete({ domain: { id: domain.id }, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple MenuColumns' })
+  async deleteMenuColumns(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(MenuColumn).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple MenuColumns' })
+  async importMenuColumns(
+    @Arg('menuColumns', type => [MenuColumnPatch]) menuColumns: MenuColumnPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      menuColumns.map(async (menuColumn: MenuColumnPatch) => {
+        await tx.getRepository(MenuColumn).save({ domain, ...(menuColumn as any) })
+      })
+    )
+
+    return true
+  }
+}