@things-factory/work-shift 6.0.75 → 6.0.78

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@things-factory/work-shift",
-  "version": "6.0.75",
+  "version": "6.0.78",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
   "description": "Module to handle work shift",
+  "license": "MIT",
   "publishConfig": {
     "access": "public",
     "@things-factory:registry": "https://registry.npmjs.org"
@@ -23,10 +24,10 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^6.0.75",
-    "@things-factory/env": "^6.0.71",
-    "@things-factory/shell": "^6.0.75",
+    "@things-factory/auth-base": "^6.0.78",
+    "@things-factory/env": "^6.0.78",
+    "@things-factory/shell": "^6.0.78",
     "moment-timezone": "^0.5.40"
   },
-  "gitHead": "f7ca179a7fabfc129a9981a7bd734380a3ac64f0"
+  "gitHead": "6d1b076baae617ee1c1df25e176c21d7b1a18e61"
 }

package/server/controllers/index.ts

@@ -4,36 +4,97 @@ import { logger } from '@things-factory/env'
 import { Domain, getRepository } from '@things-factory/shell'
 
 import { WorkShift, WorkShiftDateType } from '../service/work-shift/work-shift'
-import { WorkDateWorkShiftPair } from '../service/work-shift/work-shift-type'
-
-function between(
-  fromDate: WorkShiftDateType,
-  fromTime: string /* hh:mm */,
-  toDate: WorkShiftDateType,
-  toTime: string /* hh:mm */,
-  theDay: Date,
-  dateTime: Date
-): boolean {
-  const convertedFromDate = new Date(theDay.getTime() + fromDate * (24 * 60 * 60 * 1000))
-  const convertedToDate = new Date(theDay.getTime() + toDate * (24 * 60 * 60 * 1000))
-  const from = new Date(`${convertedFromDate.toISOString().split('T')[0]}T${fromTime}`)
-  const to = new Date(`${convertedToDate.toISOString().split('T')[0]}T${toTime}`)
-
-  return dateTime >= from && to > dateTime
+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 getWorkDateAndShift(
+export async function getDateRangeForWorkDate(
   domain: Domain,
-  dateTime: Date,
-  options?: any
-): Promise<WorkDateWorkShiftPair> {
+  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 = dateTime.toISOString().split('T')[0]
   const givenDate = moment(dateTime).tz(timezone)
-  const localDate = new Date(givenDate.format('YYYY-MM-DD HH:mm:ss'))
-  const workDate = givenDate.format(format)
   /* 1. get work-shift list for the domain */
   const workShifts = await getRepository(WorkShift).find({
     where: {
@@ -46,23 +107,132 @@ export async function getWorkDateAndShift(
   })
 
   /* 2. compare given date-time to every work-shift */
-  if (workShifts && workShifts.length > 0) {
-    const theDay = new Date(givenDate.format('YYYY-MM-DD'))
-    const theDayBefore = new Date(theDay.getTime() - 24 * 60 * 60 * 1000)
-    const theDayAfter = new Date(theDay.getTime() + 24 * 60 * 60 * 1000)
+  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 theDay = days[i]
+      const day = days[i]
+      dateBegin = null
 
       for (let j = 0; j < workShifts.length; j++) {
         const { name, fromDate, fromTime, toDate, toTime } = workShifts[j]
 
-        if (between(fromDate, fromTime, toDate, toTime, theDay, localDate)) {
+        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,
-            workShift: name
+            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
           }
         }
       }
@@ -71,9 +241,10 @@ export async function getWorkDateAndShift(
     logger.error(new Error('shift not found'))
   }
 
-  /* 3. in case there are no work-shift, just give date and default shift 'NA' */
+  /* 3. in case there are no work-shift, just give date and default shift '' */
   return {
-    workDate,
-    workShift: 'NA'
+    workDate: givenDate.clone().subtract(1, 'day').format(format),
+    workShift: '',
+    dateRange: [theDayBefore.toDate(), theDay.toDate()]
   }
 }

package/server/index.ts

@@ -1,6 +1,2 @@
 export * from './controllers'
-export * from './migrations'
-export * from './middlewares'
 export * from './service'
-
-import './routes'

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

@@ -5,15 +5,12 @@ import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from
 
 import { getWorkDateAndShift } from '../../controllers/index'
 import { WorkShift } from './work-shift'
-import { WorkDateWorkShiftPair, WorkShiftList } from './work-shift-type'
+import { WorkShiftInfo, WorkShiftList } from './work-shift-type'
 
 @Resolver(Domain)
 export class DomainWorkShiftQuery {
-  @Query(returns => WorkDateWorkShiftPair, { description: 'To fetch a work date and work shift for given datetime' })
-  async getWorkDateAndShift(
-    @Arg('dateTime') dateTime: Date,
-    @Ctx() context: ResolverContext
-  ): Promise<WorkDateWorkShiftPair> {
+  @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)

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

@@ -32,10 +32,16 @@ export class WorkShiftList {
 }
 
 @ObjectType()
-export class WorkDateWorkShiftPair {
-  @Field()
-  workDate: string
+export class WorkShiftInfo {
+  @Field({ nullable: true })
+  workDate?: string
 
-  @Field()
-  workShift: string
+  @Field({ nullable: true })
+  workShift?: string
+
+  @Field(type => [Date], { nullable: true })
+  dateRange?: Date[]
+
+  @Field(type => [Date], { nullable: true })
+  shiftRange?: Date[]
 }

package/server/middlewares/index.ts

@@ -1,3 +0,0 @@
-export function initMiddlewares(app) {
-  /* can add middlewares into app */
-}

package/server/migrations/index.ts

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

@@ -1,26 +0,0 @@
-process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
-  /*
-   * can add global public routes to application (auth not required, tenancy not required)
-   *
-   * ex) routes.get('/path', async(context, next) => {})
-   * ex) routes.post('/path', async(context, next) => {})
-   */
-})
-
-process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
-  /*
-   * can add global private routes to application (auth required, tenancy not required)
-   */
-})
-
-process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
-  /*
-   * can add domain public routes to application (auth not required, tenancy required)
-   */
-})
-
-process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
-  /*
-   * can add domain private routes to application (auth required, tenancy required)
-   */
-})