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

package/package.json

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

package/server/entities/index.ts

@@ -0,0 +1,5 @@
+import { Tutorial } from './tutorial'
+import { TutorialRole } from './tutorial-role'
+
+export const entities = [Tutorial, TutorialRole]
+export { Tutorial, TutorialRole }

package/server/entities/tutorial-role.ts

@@ -0,0 +1,48 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  OneToMany,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { Domain } from '@things-factory/shell'
+import { User, Role } from '@things-factory/auth-base'
+import { Tutorial } from '.'
+
+@Entity()
+@Index('ix_tutorial-role_0', (tutorialRole: TutorialRole) => [tutorialRole.domain, tutorialRole.name], { unique: true })
+export class TutorialRole {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column()
+  name: string
+
+  @ManyToOne(type => Role)
+  role: Role
+
+  @ManyToOne(type => Tutorial)
+  tutorial: Tutorial
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/entities/tutorial.ts

@@ -0,0 +1,57 @@
+import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
+import { Domain } from '@things-factory/shell'
+import { User, Role } from '@things-factory/auth-base'
+
+@Entity()
+@Index('ix_tutorial_0', (tutorial: Tutorial) => [tutorial.domain, tutorial.name], { unique: true })
+export class Tutorial {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  description: string
+
+  @Column({
+    nullable: true
+  })
+  resourceUrl: string
+
+  @Column({
+    nullable: true
+  })
+  value: string
+
+  @Column({
+    nullable: true
+  })
+  duration: string
+
+  @Column('int', {
+    nullable: true
+  })
+  rank: number
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/graphql/index.ts

@@ -0,0 +1,7 @@
+import * as typeDefs from './types'
+import * as resolvers from './resolvers'
+
+export const schema = {
+  typeDefs,
+  resolvers
+}

package/server/graphql/resolvers/index.ts

@@ -0,0 +1,6 @@
+import * as Tutorial from './tutorial'
+import * as TutorialRole from './tutorial-role'
+
+export const queries = [Tutorial.Query, TutorialRole.Query]
+
+export const mutations = [Tutorial.Mutation, TutorialRole.Mutation]

package/server/graphql/resolvers/tutorial/delete-tutorials.ts

@@ -0,0 +1,14 @@
+import { In } from 'typeorm'
+
+import { Tutorial } from '../../../entities'
+
+export const deleteTutorials = {
+  async deleteTutorials(_: any, { ids }, context: ResolverContext) {
+    const { tx, domain } = context.state
+    await tx.getRepository(Tutorial).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+    return true
+  }
+}

package/server/graphql/resolvers/tutorial/index.ts

@@ -0,0 +1,15 @@
+import { tutorialResolver } from './tutorial'
+import { tutorialsResolver } from './tutorials'
+
+import { updateMultipleTutorial } from './update-multiple-tutorial'
+import { deleteTutorials } from './delete-tutorials'
+
+export const Query = {
+  ...tutorialsResolver,
+  ...tutorialResolver
+}
+
+export const Mutation = {
+  ...updateMultipleTutorial,
+  ...deleteTutorials
+}

package/server/graphql/resolvers/tutorial/tutorial.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { Tutorial } from '../../../entities'
+
+export const tutorialResolver = {
+  async tutorial(_: any, { name }, context: ResolverContext) {
+    const { domain } = context.state
+
+    return await getRepository(Tutorial).findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+}

package/server/graphql/resolvers/tutorial/tutorials.ts

@@ -0,0 +1,38 @@
+import { SelectQueryBuilder } from 'typeorm'
+
+import { Role } from '@things-factory/auth-base'
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Tutorial, TutorialRole } from '../../../entities'
+
+export const tutorialsResolver = {
+  async tutorials(_: any, params: ListParam, context: ResolverContext) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(Tutorial).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  },
+
+  async tutorialsWithRoles(_: any, { roleNames }, context: ResolverContext) {
+    let filter: string[] = roleNames.split(',')
+    const qb: SelectQueryBuilder<Tutorial> = getRepository(Tutorial)
+      .createQueryBuilder('tutorial')
+      .select('tutorial.id', 'id')
+      .addSelect('tutorial.name', 'name')
+      .addSelect('tutorial.description', 'description')
+      .addSelect('tutorial.resourceUrl', 'resourceUrl')
+      .addSelect('tutorial.value', 'value')
+      .addSelect('tutorial.duration', 'duration')
+      .addSelect('tutorial.rank', 'rank')
+      .innerJoin(TutorialRole, 'tr', 'tr.tutorial_id = tutorial.id')
+      .innerJoin(Role, 'role', 'role.id = tr.role_id')
+      .where('UPPER(role.name) IN (:...input)', { input: filter })
+      .groupBy('tutorial.id')
+      .orderBy('tutorial.rank')
+
+    let data = await qb.getRawMany()
+    return data
+  }
+}

package/server/graphql/resolvers/tutorial/update-multiple-tutorial.ts

@@ -0,0 +1,44 @@
+import { Tutorial } from '../../../entities'
+
+export const updateMultipleTutorial = {
+  async updateMultipleTutorial(_: any, { patches }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const tutorialRepo = tx.getRepository(Tutorial)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await tutorialRepo.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 tutorial = await tutorialRepo.findOneBy({ id: newRecord.id })
+
+        const result = await tutorialRepo.save({
+          ...tutorial,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/tutorial-role/index.ts

@@ -0,0 +1,16 @@
+import { tutorialRoleResolver } from './tutorial-role'
+import { tutorialRolesResolver } from './tutorial-roles'
+import { tutorialRoleAssignmentsResolver } from './tutorial-role-assignments'
+import { listByRolesResolver } from './list-by-roles'
+import { updateRoleTutorial } from './update-role-tutorial'
+
+export const Query = {
+  ...tutorialRolesResolver,
+  ...tutorialRoleResolver,
+  ...tutorialRoleAssignmentsResolver,
+  ...listByRolesResolver
+}
+
+export const Mutation = {
+  ...updateRoleTutorial
+}

package/server/graphql/resolvers/tutorial-role/list-by-roles.ts

@@ -0,0 +1,21 @@
+import { SelectQueryBuilder } from 'typeorm'
+
+import { Role } from '@things-factory/auth-base'
+import { getRepository, ListParam } from '@things-factory/shell'
+
+import { TutorialRole } from '../../../entities'
+
+export const listByRolesResolver = {
+  async listByRoles(_: any, params: ListParam, context: ResolverContext) {
+    const qb: SelectQueryBuilder<TutorialRole> = getRepository(TutorialRole)
+      .createQueryBuilder('tr')
+      .select('tr.role_id', 'id')
+      .addSelect('r.name', 'name')
+      .innerJoin(Role, 'r', 'r.id = tr.role_id')
+      .groupBy('tr.role_id')
+      .addGroupBy('r.name')
+
+    let data = await qb.getRawMany()
+    return data
+  }
+}

package/server/graphql/resolvers/tutorial-role/tutorial-role-assignments.ts

@@ -0,0 +1,26 @@
+import { Role } from '@things-factory/auth-base'
+import { getRepository } from '@things-factory/shell'
+
+import { TutorialRole } from '../../../entities'
+
+export const tutorialRoleAssignmentsResolver = {
+  async tutorialRoleAssignments(_: any, { tutorialId }, context: ResolverContext) {
+    const tutorialRole = await getRepository(TutorialRole).find({
+      where: {
+        tutorial: tutorialId
+      },
+      relations: ['role', 'tutorial', 'domain']
+    })
+
+    let items: any[], total: number
+    ;[items, total] = await getRepository(Role).findAndCount({
+      relations: ['domain', 'creator', 'updater']
+    })
+
+    items.map(item => {
+      item.assigned = !!tutorialRole.some(tutorialRole => tutorialRole.role.id === item.id)
+    })
+
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/tutorial-role/tutorial-role.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { TutorialRole } from '../../../entities'
+
+export const tutorialRoleResolver = {
+  async tutorialRole(_: any, { name }, context: ResolverContext) {
+    const { domain } = context.state
+
+    return await getRepository(TutorialRole).findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+}

package/server/graphql/resolvers/tutorial-role/tutorial-roles.ts

@@ -0,0 +1,14 @@
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { TutorialRole } from '../../../entities'
+
+export const tutorialRolesResolver = {
+  async tutorialRoles(_: any, params: ListParam, context: ResolverContext) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(TutorialRole).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/tutorial-role/update-role-tutorial.ts

@@ -0,0 +1,47 @@
+import { Role } from '@things-factory/auth-base'
+
+import { Tutorial, TutorialRole } from '../../../entities'
+
+const crypto = require('crypto')
+
+export const updateRoleTutorial = {
+  async updateRoleTutorial(_: any, { tutorialId, tutorialRoles }, context: ResolverContext) {
+    try {
+      const { tx, domain } = context.state
+
+      const tutorial: Tutorial = await tx.getRepository(Tutorial).findOne({
+        where: { id: tutorialId }
+      })
+      if (!tutorial) throw new Error('Tutorial not exist')
+
+      // 1. Delete every tutorial roles related with current tutorial.
+      await tx.getRepository(TutorialRole).delete({ id: tutorial.id })
+
+      // 2. Append new role into tutorial roles.
+      tutorialRoles.forEach(async (tutorialRole: TutorialRole) => {
+        await tx.getRepository(TutorialRole).insert({
+          name: crypto.randomUUID(),
+          domain,
+          tutorial: tutorialId,
+          role: await tx.getRepository(Role).findOneBy({ id: tutorialRole.role.id })
+        })
+      })
+
+      const tutorials = await tx.getRepository(Tutorial).find()
+      const rolesTutorial = await tx
+        .getRepository(TutorialRole)
+        .find({ where: { id: tutorial.id }, relations: ['tutorial'] })
+      return tutorials.map((tutorial: Tutorial) => {
+        return {
+          name: tutorial.name,
+          domain,
+          tutorial: tutorial.id,
+          assigned:
+            rolesTutorial.filter((tutorialRole: TutorialRole) => tutorialRole.tutorial.id === tutorial.id).length > 0
+        }
+      })
+    } catch (e) {
+      throw e
+    }
+  }
+}

package/server/graphql/types/index.ts

@@ -0,0 +1,8 @@
+import * as Tutorial from './tutorial'
+import * as TutorialRole from './tutorial-role'
+
+export const queries = [Tutorial.Query, TutorialRole.Query]
+
+export const mutations = [Tutorial.Mutation, TutorialRole.Mutation]
+
+export const types = [...Tutorial.Types, ...TutorialRole.Types]

package/server/graphql/types/tutorial/index.ts

@@ -0,0 +1,22 @@
+import { Tutorial } from './tutorial'
+import { NewTutorial } from './new-tutorial'
+import { TutorialPatch } from './tutorial-patch'
+import { TutorialList } from './tutorial-list'
+
+export const Mutation = `
+  updateMultipleTutorial (
+    patches: [TutorialPatch]!
+  ): [Tutorial] @transaction
+
+  deleteTutorials (
+    ids: [String]!
+  ): Boolean @transaction
+`
+
+export const Query = `
+  tutorials(filters: [Filter], pagination: Pagination, sortings: [Sorting]): TutorialList
+  tutorialsWithRoles(roleNames: String!): [Tutorial]
+  tutorial(name: String!): Tutorial
+`
+
+export const Types = [Tutorial, NewTutorial, TutorialPatch, TutorialList]

package/server/graphql/types/tutorial/new-tutorial.ts

@@ -0,0 +1,13 @@
+import gql from 'graphql-tag'
+
+export const NewTutorial = gql`
+  input NewTutorial {
+    name: String!
+    description: String
+    resourceUrl: String
+    value: String
+    duration: String
+    rank: Int
+    roles: [ObjectRef]
+  }
+`

package/server/graphql/types/tutorial/tutorial-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const TutorialList = gql`
+  type TutorialList {
+    items: [Tutorial]
+    total: Int
+  }
+`

package/server/graphql/types/tutorial/tutorial-patch.ts

@@ -0,0 +1,15 @@
+import gql from 'graphql-tag'
+
+export const TutorialPatch = gql`
+  input TutorialPatch {
+    id: String
+    name: String
+    description: String
+    resourceUrl: String
+    value: String
+    duration: String
+    rank: Int
+    roles: [ObjectRef]
+    cuFlag: String
+  }
+`

package/server/graphql/types/tutorial/tutorial.ts

@@ -0,0 +1,19 @@
+import gql from 'graphql-tag'
+
+export const Tutorial = gql`
+  type Tutorial {
+    id: String
+    name: String
+    domain: Domain
+    description: String
+    resourceUrl: String
+    value: String
+    duration: String
+    rank: Int
+    roles: [Role]
+    updater: User
+    creator: User
+    updatedAt: String
+    createdAt: String
+  }
+`

package/server/graphql/types/tutorial-role/index.ts

@@ -0,0 +1,22 @@
+import { TutorialRole } from './tutorial-role'
+import { NewTutorialRole } from './new-tutorial-role'
+import { TutorialRolePatch } from './tutorial-role-patch'
+import { TutorialRoleList } from './tutorial-role-list'
+import { RoleList } from './role-list'
+import { RoleTutorial } from './role-tutorial'
+
+export const Mutation = `
+  updateRoleTutorial (
+    tutorialId: String!
+    tutorialRoles: [TutorialRolePatch]!
+  ): [RoleTutorial] @privilege(category: "tutorial", privilege: "mutation") @transaction
+`
+
+export const Query = `
+  tutorialRoles(filters: [Filter], pagination: Pagination, sortings: [Sorting]): TutorialRoleList
+  tutorialRole(name: String!): TutorialRole
+  tutorialRoleAssignments(tutorialId: String!): TutorialRoleList
+  listByRoles(filters: [Filter]): [RoleTutorial]
+`
+
+export const Types = [TutorialRole, NewTutorialRole, TutorialRolePatch, TutorialRoleList, RoleList, RoleTutorial]

package/server/graphql/types/tutorial-role/new-tutorial-role.ts

@@ -0,0 +1,9 @@
+import gql from 'graphql-tag'
+
+export const NewTutorialRole = gql`
+  input NewTutorialRole {
+    name: String!
+    tutorial: ObjectRef!
+    roles: [ObjectRef]!
+  }
+`

package/server/graphql/types/tutorial-role/role-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const RoleList = gql`
+  type RoleList {
+    items: [Role]
+    total: Int
+  }
+`

package/server/graphql/types/tutorial-role/role-tutorial.ts

@@ -0,0 +1,11 @@
+import gql from 'graphql-tag'
+
+export const RoleTutorial = gql`
+  type RoleTutorial {
+    id: String
+    name: String
+    role: Role
+    tutorial: Tutorial
+    assigned: Boolean
+  }
+`

package/server/graphql/types/tutorial-role/tutorial-role-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const TutorialRoleList = gql`
+  type TutorialRoleList {
+    items: [TutorialRole]
+    total: Int
+  }
+`

package/server/graphql/types/tutorial-role/tutorial-role-patch.ts

@@ -0,0 +1,11 @@
+import gql from 'graphql-tag'
+
+export const TutorialRolePatch = gql`
+  input TutorialRolePatch {
+    id: String
+    name: String
+    role: ObjectRef
+    tutorial: ObjectRef
+    cuFlag: String
+  }
+`

package/server/graphql/types/tutorial-role/tutorial-role.ts

@@ -0,0 +1,17 @@
+import gql from 'graphql-tag'
+
+export const TutorialRole = gql`
+  type TutorialRole {
+    id: String
+    name: String
+    domain: Domain
+    role: Role
+    tutorial: Tutorial
+    description: String
+    assigned: Boolean
+    updater: User
+    creator: User
+    updatedAt: String
+    createdAt: String
+  }
+`

package/server/index.ts

@@ -0,0 +1,3 @@
+export * from './entities'
+export * from './migrations'
+export * from './graphql'

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/routes.ts

@@ -0,0 +1,21 @@
+process.on('bootstrap-module-history-fallback' as any, (app, fallbackOption) => {
+  /*
+   * fallback white list를 추가할 수 있다
+   *
+   * ex)
+   * var paths = [
+   *   'aaa',
+   *   'bbb'
+   * ]
+   * fallbackOption.whiteList.push(`^\/(${paths.join('|')})($|[/?#])`)
+   */
+})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, routes) => {
+  /*
+   * koa application에 routes 를 추가할 수 있다.
+   *
+   * ex) routes.get('/path', async(context, next) => {})
+   * ex) routes.post('/path', async(context, next) => {})
+   */
+})