@things-factory/work-shift 8.0.5 → 9.0.0-beta.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/work-shift",
-  "version": "8.0.5",
+  "version": "9.0.0-beta.12",
   "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.5",
-    "@things-factory/env": "^8.0.2",
-    "@things-factory/shell": "^8.0.2",
+    "@things-factory/auth-base": "^9.0.0-beta.12",
+    "@things-factory/env": "^9.0.0-beta.5",
+    "@things-factory/shell": "^9.0.0-beta.12",
     "moment-timezone": "^0.5.40"
   },
-  "gitHead": "9ab6fca18eeb58b9d2f3411661508a39d0ab6aee"
+  "gitHead": "5e9ade1c2d4b4c96b89396e36c3afa1caaf18ef0"
 }

package/client/bootstrap.ts

@@ -1 +0,0 @@
-export default function bootstrap() {}

package/client/pages/work-shift.ts

@@ -1,108 +0,0 @@
-import '@operato/input/ox-input-work-shift.js'
-import '@operato/context/ox-context-page-toolbar.js'
-
-import { css, html } from 'lit'
-import { customElement, query, state } from 'lit/decorators.js'
-import gql from 'graphql-tag'
-
-import { OxFormField } from '@operato/input'
-import { PageView, store } from '@operato/shell'
-import { CommonHeaderStyles, ScrollbarStyles } from '@operato/styles'
-import { client } from '@operato/graphql'
-import { connect } from 'pwa-helpers/connect-mixin.js'
-import { i18next } from '@operato/i18n'
-
-@customElement('work-shift')
-class WorkShift extends connect(store)(PageView) {
-  static styles = [
-    ScrollbarStyles,
-    CommonHeaderStyles,
-    css`
-      :host {
-        background-color: var(--md-sys-color-background);
-        padding: var(--spacing-large);
-        overflow: auto;
-      }
-
-      ox-input-work-shift {
-        overflow-y: auto;
-        flex: 1;
-      }
-    `
-  ]
-
-  @state() private workShifts: any[] = []
-
-  @query('ox-input-work-shift') private input!: OxFormField
-
-  get context() {
-    return {
-      title: i18next.t('title.work-shift'),
-      actions: [
-        {
-          title: i18next.t('button.update'),
-          action: this.updateWorkShift.bind(this),
-          icon: 'save'
-        }
-      ],
-      help: 'page/work-shift',
-      toolbar: false
-    }
-  }
-
-  render() {
-    return html`
-      <div class="header">
-        <div class="title">${i18next.t('title.work-shift')}</div>
-
-        <ox-context-page-toolbar class="actions" .context=${this.context}> </ox-context-page-toolbar>
-      </div>
-
-      <ox-input-work-shift .value=${this.workShifts}></ox-input-work-shift>
-    `
-  }
-
-  async pageUpdated(changes, after, before) {
-    /* refresh always page revisited */
-    if (this.active) {
-      const response = await client.query({
-        query: gql`
-          query {
-            workShifts(sortings: [{ name: "fromDate" }, { name: "fromTime" }]) {
-              items {
-                name
-                fromDate
-                fromTime
-                toDate
-                toTime
-              }
-            }
-          }
-        `
-      })
-
-      this.workShifts = response.data.workShifts.items
-    }
-  }
-
-  private async updateWorkShift() {
-    const response = await client.mutate({
-      mutation: gql`
-        mutation ($patches: [WorkShiftPatch!]!) {
-          updateMultipleWorkShift(patches: $patches) {
-            name
-            fromDate
-            fromTime
-            toDate
-            toTime
-          }
-        }
-      `,
-      variables: {
-        patches: this.input.value
-      }
-    })
-
-    this.workShifts = response.data.updateMultipleWorkShift
-  }
-}

package/client/route.ts

@@ -1,7 +0,0 @@
-export default function route(page) {
-  switch (page) {
-    case 'work-shift':
-      import('./pages/work-shift')
-      return page
-  }
-}

package/client/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig-base.json",
-  "compilerOptions": {
-    "experimentalDecorators": true,
-    "skipLibCheck": true,
-    "strict": true,
-    "declaration": true,
-    "module": "esnext",
-    "outDir": "../dist-client",
-    "baseUrl": "./"
-  },
-  "include": ["./**/*"]
-}

package/server/controllers/index.ts

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

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

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

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

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

package/server/service/index.ts

@@ -1,18 +0,0 @@
-/* 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

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

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

@@ -1,67 +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 { 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

@@ -1,47 +0,0 @@
-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[]
-}