@things-factory/spc 8.0.0-beta.8 → 8.0.0

package/server/service/index.ts

@@ -0,0 +1,21 @@
+/* EXPORT ENTITY TYPES */
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as SpcChartEntities, resolvers as SpcChartResolvers, subscribers as SpcChartSubscribers } from './spc-chart'
+
+export const entities = [
+  /* ENTITIES */
+  ...SpcChartEntities
+]
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...SpcChartSubscribers
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...SpcChartResolvers
+  ]
+}

package/server/service/spc-chart/index.ts

@@ -0,0 +1,5 @@
+import { SpcChartQuery } from './spc-chart-query'
+
+export const entities = []
+export const resolvers = [SpcChartQuery]
+export const subscribers = []

package/server/service/spc-chart/spc-chart-query.ts

@@ -0,0 +1,102 @@
+import { Resolver, Query, Arg, Ctx } from 'type-graphql'
+import { Between, In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { DataSet, DataSample } from '@things-factory/dataset'
+
+import { SPCChartAnalysis, SPCChartAnalysisResult } from './spc-chart-type'
+import { calculateXBarAnalysisResult } from '../../controllers/spc-chart/x-bar'
+import { calculateRChartAnalysisResult } from '../../controllers/spc-chart/r'
+import { calculateIChartAnalysisResult } from '../../controllers/spc-chart/i'
+import { calculateMRChartAnalysisResult } from '../../controllers/spc-chart/mr'
+import { calculateUChartAnalysisResult } from '../../controllers/spc-chart/u'
+import { calculateCChartAnalysisResult } from '../../controllers/spc-chart/c'
+import { calculatePChartAnalysisResult } from '../../controllers/spc-chart/p'
+import { calculateNPChartAnalysisResult } from '../../controllers/spc-chart/np'
+
+@Resolver(DataSet)
+export class SpcChartQuery {
+  @Query(returns => SPCChartAnalysisResult!, { nullable: true, description: 'To fetch a SpcChart' })
+  async spcChart(
+    @Arg('dataSetId') dataSetId: string,
+    @Arg('variable') variable: string,
+    @Arg('chartType') chartType: string,
+    @Arg('fromDate') fromDate: string,
+    @Arg('toDate') toDate: string,
+    @Ctx() context: ResolverContext
+  ): Promise<SPCChartAnalysisResult> {
+    const { domain } = context.state
+
+    const dataSet = (await getRepository(DataSet).findOne({
+      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id: dataSetId }
+    })) as DataSet
+
+    if (!dataSet) {
+      throw 'no given dataset'
+    }
+
+    const dataItem = dataSet.dataItems.find(dataItem => dataItem.name == variable)
+
+    if (!dataItem) {
+      throw 'no given variables in the dataset'
+    }
+
+    // TODO timezone
+    const fromTime = new Date(fromDate) /* default: 30days before */
+    const toTime = new Date(toDate) /* default: today */
+
+    const dataSamples = (await getRepository(DataSample).find({
+      where: {
+        dataSet: { id: dataSet.id },
+        createdAt: Between(fromTime, toTime)
+      }
+    })) as DataSample[]
+
+    const tag = dataItem.tag
+    const samples = dataSamples
+      .map(dataSample => {
+        const data = dataSample.data[tag]
+
+        return {
+          x: dataSample.createdAt,
+          values: Array.isArray(data) ? data : [data]
+        }
+      })
+      .filter(sample => {
+        const { x, values } = sample
+        return x && values && values.length > 0 && values.every(v => v ?? false)
+      })
+
+    const charts = [] as SPCChartAnalysis[]
+
+    switch (chartType) {
+      case 'Xbar-R':
+        charts.push(calculateXBarAnalysisResult(samples as any))
+        charts.push(calculateRChartAnalysisResult(samples as any))
+        break
+      case 'I-MR':
+        charts.push(calculateIChartAnalysisResult(samples as any))
+        charts.push(calculateMRChartAnalysisResult(samples as any))
+        break
+      case 'C':
+        charts.push(calculateUChartAnalysisResult(samples as any))
+        break
+      case 'U':
+        charts.push(calculateCChartAnalysisResult(samples as any))
+        break
+      case 'P':
+        charts.push(calculatePChartAnalysisResult(samples as any))
+        break
+      case 'NP':
+        charts.push(calculateNPChartAnalysisResult(samples as any))
+        break
+    }
+
+    return {
+      dataSet,
+      variable,
+      charts
+    }
+  }
+}

package/server/service/spc-chart/spc-chart-type.ts

@@ -0,0 +1,105 @@
+import { ObjectType, Field, ID, Int, Float } from 'type-graphql'
+
+import { DataSet } from '@things-factory/dataset'
+
+@ObjectType()
+export class SPCChartPlot {
+  @Field(type => ID)
+  x: string
+
+  @Field(type => [Float], { nullable: true })
+  values?: number[]
+
+  @Field(type => Float, { nullable: true })
+  xbar?: number
+
+  @Field(type => Float, { nullable: true })
+  r?: number
+
+  @Field(type => Float, { nullable: true })
+  i?: number
+
+  @Field(type => Float, { nullable: true })
+  mr?: number
+
+  @Field(type => Float, { nullable: true })
+  n?: number
+
+  @Field(type => Float, { nullable: true })
+  defects?: number
+}
+
+@ObjectType()
+class SPCControlLimits {
+  @Field(type => Float, { nullable: true })
+  ucl?: number
+
+  @Field(type => Float, { nullable: true })
+  lcl?: number
+
+  @Field(type => Float, { nullable: true })
+  cl?: number
+}
+
+@ObjectType()
+class SPCSpecLimits {
+  @Field(type => Float, { nullable: true })
+  target?: number
+
+  @Field(type => Float, { nullable: true })
+  lsl?: number
+
+  @Field(type => Float, { nullable: true })
+  usl?: number
+}
+
+@ObjectType()
+export class SPCChartAnalysis {
+  @Field()
+  chartType: string
+
+  @Field(type => SPCControlLimits, { nullable: true })
+  controlLimits?: SPCControlLimits
+
+  @Field(type => SPCSpecLimits, { nullable: true })
+  specLimits?: SPCSpecLimits
+
+  @Field(type => [SPCChartPlot], { nullable: true })
+  plots?: SPCChartPlot[]
+
+  // @Field(type => [Bin], { nullable: true })
+  // bins?: Bin[]
+
+  // @Field(type => [Category], { nullable: true })
+  // categories?: Category[]
+}
+
+// @ObjectType()
+// class Bin {
+//   @Field()
+//   binRange: string
+
+//   @Field()
+//   count: number
+// }
+
+// @ObjectType()
+// class Category {
+//   @Field()
+//   category: string
+
+//   @Field()
+//   count: number
+// }
+
+@ObjectType()
+export class SPCChartAnalysisResult {
+  @Field(type => DataSet)
+  dataSet: DataSet
+
+  @Field()
+  variable: string
+
+  @Field(type => [SPCChartAnalysis])
+  charts: SPCChartAnalysis[]
+}

package/server/tsconfig.json

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