@things-factory/work-shift 8.0.0-beta.9 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/work-shift",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,10 +27,10 @@
     "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/env": "^8.0.0-beta.4",
-    "@things-factory/shell": "^8.0.0-beta.9",
+    "@things-factory/auth-base": "^8.0.0",
+    "@things-factory/env": "^8.0.0",
+    "@things-factory/shell": "^8.0.0",
     "moment-timezone": "^0.5.40"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/controllers/index.ts

@@ -0,0 +1,2 @@
+export * from './work-shift-range'
+export * from './work-shift-schedule'

package/server/controllers/work-shift-range.ts

@@ -0,0 +1,250 @@
+import moment from 'moment-timezone'
+
+import { logger } from '@things-factory/env'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { WorkShift } from '../service/work-shift/work-shift'
+import { WorkShiftInfo } from '../service/work-shift/work-shift-type'
+
+export async function getDateRangeForWorkShift(
+  domain: Domain,
+  workDate: string,
+  workShiftName: string,
+  options?: { timezone?: string; format?: string }
+): Promise<Date[]> {
+  const dateOptions = { timezone: domain.timezone || 'UTC', format: 'YYYY-MM-DD', ...options }
+  const { timezone, format } = dateOptions
+
+  const workShift = await getRepository(WorkShift).findOne({
+    where: {
+      domain: { id: domain.id },
+      name: workShiftName
+    }
+  })
+
+  if (!workShift) {
+    return
+  }
+  const theDay = moment.tz(workDate, timezone)
+  const { name, fromDate, fromTime, toDate, toTime } = workShift
+
+  const convertedFromDate = theDay.clone().add(fromDate, 'day')
+  const convertedToDate = theDay.clone().add(toDate, 'day')
+  const from = moment
+    .tz(`${convertedFromDate.format('YYYY-MM-DD')} ${fromTime}`, 'YYYY-MM-DD HH:mm:ss', timezone)
+    .toDate()
+  const to = moment.tz(`${convertedToDate.format('YYYY-MM-DD')} ${toTime}`, 'YYYY-MM-DD HH:mm:ss', timezone).toDate()
+
+  return [from, to]
+}
+
+export async function getDateRangeForWorkDate(
+  domain: Domain,
+  workDate: string,
+  options?: { timezone?: string; format?: string }
+) {
+  const dateOptions = { timezone: domain.timezone || 'UTC', format: 'YYYY-MM-DD', ...options }
+  const { timezone, format } = dateOptions
+
+  var beginDate
+  var endDate
+
+  /* 1. get work-shift list for the domain */
+  const workShifts = await getRepository(WorkShift).find({
+    where: {
+      domain: { id: domain.id }
+    },
+    order: {
+      fromDate: 'ASC',
+      fromTime: 'ASC'
+    }
+  })
+
+  /* 2. get date-time for every work-shift */
+  if (workShifts && workShifts.length > 0) {
+    const theDay = moment.tz(workDate, timezone)
+
+    for (let j = 0; j < workShifts.length; j++) {
+      const { name, fromDate, fromTime, toDate, toTime } = workShifts[j]
+
+      const convertedFromDate = theDay.clone().add(fromDate, 'day')
+      const convertedToDate = theDay.clone().add(toDate, 'day')
+      const from = moment
+        .tz(`${convertedFromDate.format('YYYY-MM-DD')} ${fromTime}`, 'YYYY-MM-DD HH:mm:ss', timezone)
+        .toDate()
+      const to = moment
+        .tz(`${convertedToDate.format('YYYY-MM-DD')} ${toTime}`, 'YYYY-MM-DD HH:mm:ss', timezone)
+        .toDate()
+
+      if (!beginDate) {
+        beginDate = from
+      }
+
+      endDate = to
+    }
+  } else {
+    return
+  }
+
+  /* 3. in case there are no work-shift, just give date and default shift '' */
+  return [beginDate, endDate]
+}
+
+export async function getWorkDateAndShift(domain: Domain, dateTime: Date, options?: any): Promise<WorkShiftInfo> {
+  const dateOptions = { timezone: domain.timezone || 'UTC', format: 'YYYY-MM-DD', ...options }
+  const { timezone, format } = dateOptions
+
+  const givenDate = moment(dateTime).tz(timezone)
+  /* 1. get work-shift list for the domain */
+  const workShifts = await getRepository(WorkShift).find({
+    where: {
+      domain: { id: domain.id }
+    },
+    order: {
+      fromDate: 'ASC',
+      fromTime: 'ASC'
+    }
+  })
+
+  /* 2. compare given date-time to every work-shift */
+  const theDay = givenDate.clone().startOf('day')
+  const theDayBefore = theDay.clone().subtract(1, 'day')
+  const theDayAfter = theDay.clone().add(1, 'day')
+
+  if (workShifts && workShifts.length > 0) {
+    const days = [theDayBefore, theDay, theDayAfter]
+    let dateBegin, dateEnd
+
+    for (let i = 0; i < days.length; i++) {
+      const day = days[i]
+      dateBegin = null
+
+      for (let j = 0; j < workShifts.length; j++) {
+        const { name, fromDate, fromTime, toDate, toTime } = workShifts[j]
+
+        const convertedFromDate = day.clone().add(fromDate, 'day')
+        const convertedToDate = day.clone().add(toDate, 'day')
+
+        const from = moment.tz(`${convertedFromDate.format('YYYY-MM-DD')} ${fromTime}`, 'YYYY-MM-DD HH:mm:ss', timezone)
+        const to = moment.tz(`${convertedToDate.format('YYYY-MM-DD')} ${toTime}`, 'YYYY-MM-DD HH:mm:ss', timezone)
+
+        dateBegin = dateBegin || from
+        dateEnd = from.clone().add(1, 'day')
+
+        if (dateTime >= from.toDate() && to.toDate() > dateTime) {
+          return {
+            workDate: moment(day).format(format),
+            workShift: name,
+            dateRange: [dateBegin.toDate(), dateEnd.toDate()],
+            shiftRange: [from.toDate(), to.toDate()]
+          }
+        }
+      }
+    }
+
+    logger.error(new Error('shift not found'))
+  }
+
+  /* 3. in case there are no work-shift, just give date and default shift '' */
+  return {
+    workDate: givenDate.format(format),
+    workShift: '',
+    dateRange: [theDay.toDate(), theDayAfter.toDate()]
+  }
+}
+
+export async function getLatestWorkDateAndShift(domain: Domain, dateTime: Date, options?: any): Promise<WorkShiftInfo> {
+  const dateOptions = { timezone: domain.timezone || 'UTC', format: 'YYYY-MM-DD', ...options }
+  const { timezone, format } = dateOptions
+
+  const givenDate = moment(dateTime).tz(timezone)
+
+  /* 1. get work-shift list for the domain */
+  const workShifts = await getRepository(WorkShift).find({
+    where: {
+      domain: { id: domain.id }
+    },
+    order: {
+      fromDate: 'ASC',
+      fromTime: 'ASC'
+    }
+  })
+
+  /* 2. compare given date-time to every work-shift */
+  const theDay = givenDate.clone().startOf('day')
+  const theDayBefore = theDay.clone().subtract(1, 'day')
+  const theDayAfter = theDay.clone().add(1, 'day')
+
+  if (workShifts && workShifts.length > 0) {
+    const days = [theDayBefore, theDay, theDayAfter]
+    let dateBegin, dateEnd
+
+    for (let i = 0; i < days.length; i++) {
+      const day = days[i]
+      dateBegin = null
+
+      for (let j = 0; j < workShifts.length; j++) {
+        const { name, fromDate, fromTime, toDate, toTime } = workShifts[j]
+
+        const convertedFromDate = day.clone().add(fromDate, 'day')
+        const convertedToDate = day.clone().add(toDate, 'day')
+
+        const from = moment.tz(`${convertedFromDate.format('YYYY-MM-DD')} ${fromTime}`, 'YYYY-MM-DD HH:mm:ss', timezone)
+        const to = moment.tz(`${convertedToDate.format('YYYY-MM-DD')} ${toTime}`, 'YYYY-MM-DD HH:mm:ss', timezone)
+
+        dateBegin = dateBegin || from
+        dateEnd = from.clone().add(1, 'day')
+
+        if (dateTime < from.toDate()) {
+          if (j > 0) {
+            const { name, fromDate, fromTime, toDate, toTime } = workShifts[j - 1]
+
+            const from = moment.tz(
+              `${convertedFromDate.format('YYYY-MM-DD')} ${fromTime}`,
+              'YYYY-MM-DD HH:mm:ss',
+              timezone
+            )
+            const to = moment.tz(`${convertedToDate.format('YYYY-MM-DD')} ${toTime}`, 'YYYY-MM-DD HH:mm:ss', timezone)
+
+            return {
+              workDate: moment(day).format(format),
+              workShift: name,
+              dateRange: [dateBegin.toDate(), dateEnd.toDate()],
+              shiftRange: [from.toDate(), to.toDate()]
+            }
+          } else if (i > 0) {
+            const { name, fromDate, fromTime, toDate, toTime } = workShifts[0]
+
+            const convertedFromDate = days[i - 1].clone().add(fromDate, 'day')
+            const convertedToDate = days[i - 1].clone().add(toDate, 'day')
+
+            const from = moment.tz(
+              `${convertedFromDate.format('YYYY-MM-DD')} ${fromTime}`,
+              'YYYY-MM-DD HH:mm:ss',
+              timezone
+            )
+            const to = moment.tz(`${convertedToDate.format('YYYY-MM-DD')} ${toTime}`, 'YYYY-MM-DD HH:mm:ss', timezone)
+
+            return {
+              workDate: moment(day).format(format),
+              workShift: name,
+              dateRange: [dateBegin.clone().subtract(1, 'day').toDate(), dateBegin.toDate()],
+              shiftRange: [from.toDate(), to.toDate()]
+            }
+          } else {
+            return
+          }
+        }
+      }
+    }
+
+    logger.error(new Error('shift not found'))
+  }
+
+  /* 3. in case there are no work-shift, just give date and default shift '' */
+  return {
+    workDate: givenDate.clone().subtract(1, 'day').format(format),
+    workShift: '',
+    dateRange: [theDayBefore.toDate(), theDay.toDate()]
+  }
+}

package/server/controllers/work-shift-schedule.ts

@@ -0,0 +1,79 @@
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { WorkShift } from '../service/work-shift/work-shift'
+
+export async function getSummaryScheduleForWorkShift(domain: Domain): Promise<string> {
+  const workShifts = await getRepository(WorkShift).find({
+    where: {
+      domain: { id: domain.id }
+    }
+  })
+
+  if (!workShifts || workShifts.length == 0) {
+    return ''
+  }
+
+  const hours = workShifts
+    .map(workShift => workShift.toTime)
+    .map(getNextHourIn24HourFormat)
+    .join(',')
+
+  return `10 ${hours} * * * *`
+}
+
+export async function getSummaryScheduleForWorkDate(domain: Domain): Promise<string> {
+  /* 1. 도메인의 워크시프트를 모두 가져온다. */
+  const workShifts = await getRepository(WorkShift).find({
+    where: {
+      domain: { id: domain.id }
+    },
+    order: {
+      fromDate: 'ASC',
+      fromTime: 'ASC'
+    }
+  })
+
+  /* 2. 워크데이의 마지막 시간을 구한 뒤, 그 30분뒤 시간에 매일 수행하는 crontab을 계산한다. */
+  if (workShifts && workShifts.length > 0) {
+    const { toTime } = workShifts[workShifts.length - 1]
+    return timePlusThirtyMinutesToCron(toTime)
+  } else {
+    return
+  }
+}
+
+function timePlusThirtyMinutesToCron(time: string): string {
+  const isPM = time.toUpperCase().includes('PM')
+  const [hours, minutes] = time
+    .toUpperCase()
+    .replace(/(AM|PM)/, '')
+    .split(':')
+    .map(Number)
+
+  // 기준 날짜와 시간 정보를 사용하여 Date 객체를 생성합니다.
+  let date = new Date(1970, 0, 1, isPM ? (hours % 12) + 12 : hours % 12, minutes)
+
+  // 30분을 추가합니다.
+  date.setMinutes(date.getMinutes() + 30)
+
+  // 결과 시간을 얻습니다.
+  const resultHours = String(date.getHours()).padStart(2, '0')
+  const resultMinutes = String(date.getMinutes()).padStart(2, '0')
+
+  // 결과 시간을 사용하여 crontab 항목을 반환합니다.
+  return `${resultMinutes} ${resultHours} * * * *`
+}
+
+function getNextHourIn24HourFormat(time: string): string {
+  const isPM = time.toUpperCase().includes('PM')
+  const hours = Number(time.split(':')[0])
+
+  // 기준 날짜와 시간 정보를 사용하여 Date 객체를 생성합니다.
+  let date = new Date(1970, 0, 1, isPM ? (hours % 12) + 12 : hours % 12, 0)
+
+  // 시간 값을 1 증가시킵니다.
+  date.setHours(date.getHours() + 1)
+
+  // 결과 시간을 얻습니다.
+  return String(date.getHours()).padStart(2, '0')
+}

package/server/index.ts

@@ -0,0 +1,2 @@
+export * from './controllers'
+export * from './service'

package/server/service/index.ts

@@ -0,0 +1,18 @@
+/* EXPORT ENTITY TYPES */
+export * from './work-shift/work-shift'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as WorkShiftEntities, resolvers as WorkShiftResolvers } from './work-shift'
+
+export const entities = [  
+  /* ENTITIES */
+	...WorkShiftEntities,
+] 
+
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+		...WorkShiftResolvers,
+  ] 
+}

package/server/service/work-shift/index.ts

@@ -0,0 +1,7 @@
+import { DomainWorkShiftQuery, WorkShiftQuery } from './work-shift-query'
+
+import { WorkShift } from './work-shift'
+import { WorkShiftMutation } from './work-shift-mutation'
+
+export const entities = [WorkShift]
+export const resolvers = [DomainWorkShiftQuery, WorkShiftQuery, WorkShiftMutation]

package/server/service/work-shift/work-shift-mutation.ts

@@ -0,0 +1,55 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { WorkShift } from './work-shift'
+import { WorkShiftPatch } from './work-shift-type'
+
+@Resolver(WorkShift)
+export class WorkShiftMutation {
+  @Directive('@privilege(category: "work-shift", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => [WorkShift], { description: "To modify multiple WorkShifts' information" })
+  async updateMultipleWorkShift(
+    @Arg('patches', type => [WorkShiftPatch]) patches: WorkShiftPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<WorkShift[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const workShiftRepo = tx.getRepository(WorkShift)
+
+    await workShiftRepo.delete({ domain: { id: domain.id } })
+
+    for (let i = 0; i < patches.length; i++) {
+      const patch = patches[i]
+
+      const result = await workShiftRepo.save({
+        ...patch,
+        domain,
+        creator: user,
+        updater: user
+      })
+
+      results.push({ ...result, cuFlag: '+' })
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "work-shift", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple workShifts' })
+  async deleteWorkShifts(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(WorkShift).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/work-shift/work-shift-query.ts

@@ -0,0 +1,67 @@
+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 { getWorkDateAndShift } from '../../controllers/index'
+import { WorkShift } from './work-shift'
+import { WorkShiftInfo, WorkShiftList } from './work-shift-type'
+
+@Resolver(Domain)
+export class DomainWorkShiftQuery {
+  @Query(returns => WorkShiftInfo, { description: 'To fetch a work date and work shift for given datetime' })
+  async getWorkDateAndShift(@Arg('dateTime') dateTime: Date, @Ctx() context: ResolverContext): Promise<WorkShiftInfo> {
+    const { domain } = context.state
+
+    return await getWorkDateAndShift(domain, dateTime)
+  }
+
+  @FieldResolver(type => [WorkShift])
+  async workShifts(@Root() domain: Domain): Promise<WorkShift[]> {
+    return await getRepository(WorkShift).find({
+      where: {
+        domain: { id: domain.id }
+      },
+      order: {
+        fromDate: 'ASC',
+        fromTime: 'ASC'
+      }
+    })
+  }
+}
+
+@Resolver(WorkShift)
+export class WorkShiftQuery {
+  @Query(returns => WorkShiftList, { description: 'To fetch multiple WorkShifts' })
+  async workShifts(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<WorkShiftList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(WorkShift),
+      params,
+      domain
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() workShift: WorkShift): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: workShift.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() workShift: WorkShift): Promise<User> {
+    return await getRepository(User).findOneBy({ id: workShift.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() workShift: WorkShift): Promise<User> {
+    return await getRepository(User).findOneBy({ id: workShift.creatorId })
+  }
+}

package/server/service/work-shift/work-shift-type.ts

@@ -0,0 +1,47 @@
+import { Field, ID, InputType, Int, ObjectType, registerEnumType } from 'type-graphql'
+import { WorkShift, WorkShiftDateType } from './work-shift'
+
+@InputType()
+export class WorkShiftPatch {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field()
+  fromDate: WorkShiftDateType
+
+  @Field()
+  fromTime: string
+
+  @Field()
+  toDate: WorkShiftDateType
+
+  @Field()
+  toTime: string
+}
+
+@ObjectType()
+export class WorkShiftList {
+  @Field(type => [WorkShift])
+  items: WorkShift[]
+
+  @Field(type => Int)
+  total: number
+}
+
+@ObjectType()
+export class WorkShiftInfo {
+  @Field({ nullable: true })
+  workDate?: string
+
+  @Field({ nullable: true })
+  workShift?: string
+
+  @Field(type => [Date], { nullable: true })
+  dateRange?: Date[]
+
+  @Field(type => [Date], { nullable: true })
+  shiftRange?: Date[]
+}

package/server/service/work-shift/work-shift.ts

@@ -0,0 +1,92 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { Field, ID, Int, ObjectType, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+export enum WorkShiftDateType {
+  TheDayBefore = -1,
+  TheDay = 0,
+  TheDayAfter = 1
+}
+
+registerEnumType(WorkShiftDateType, {
+  name: 'WorkShiftDateType',
+  description: 'enumeration of a shift date'
+})
+
+@Entity()
+@Index('ix_work_shift_0', (workShift: WorkShift) => [workShift.domain, workShift.name], { unique: true })
+@Index('ix_work_shift_1', (workShift: WorkShift) => [workShift.domain, workShift.fromDate, workShift.fromTime], {
+  unique: true
+})
+@ObjectType({ description: 'Entity for WorkShift' })
+export class WorkShift {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((workShift: WorkShift) => workShift.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column()
+  @Field({ nullable: true })
+  fromDate: WorkShiftDateType
+
+  @Column()
+  @Field({ nullable: true })
+  fromTime: string
+
+  @Column()
+  @Field({ nullable: true })
+  toDate: WorkShiftDateType
+
+  @Column()
+  @Field({ nullable: true })
+  toTime: 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((workShift: WorkShift) => workShift.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((workShift: WorkShift) => workShift.updater)
+  updaterId?: string
+}

package/server/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "strict": false,
+    "module": "commonjs",
+    "outDir": "../dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"]
+}