@things-factory/menu-base 8.0.38 → 9.0.0-9.0.0-beta.59.0

package/server/service/menu/menu.ts

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

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

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

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

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

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

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

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