@things-factory/id-rule-base 8.0.0-beta.9 → 8.0.2

package/server/service/id-rule/id-rule-mutation.ts

@@ -0,0 +1,34 @@
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
+
+import { getRepository } from '@things-factory/shell'
+
+import { IdRule } from './id-rule'
+import { IdRulePatch, NewIdRule } from './id-rule-types'
+
+@Resolver(IdRule)
+export class IdRuleMutation {
+  @Mutation(returns => IdRule)
+  async createIdRule(@Arg('idRule') idRule: NewIdRule, @Ctx() context: any) {
+    return await getRepository(IdRule).save({
+      ...idRule,
+      domain: context.state.domain
+    })
+  }
+
+  @Mutation(returns => IdRule)
+  async updateIdRule(
+    @Arg('type') type: string,
+    @Arg('patch') patch: IdRulePatch,
+    @Ctx() context: any
+  ): Promise<IdRule> {
+    const repository = getRepository(IdRule)
+    const idRule = await repository.findOne({
+      where: { type: type as any, domain: { id: context.state.domain.id } }
+    })
+
+    return await repository.save({
+      ...idRule,
+      ...patch
+    })
+  }
+}

package/server/service/id-rule/id-rule-query.ts

@@ -0,0 +1,25 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { IdRule } from './id-rule'
+
+@Resolver(IdRule)
+export class IdRuleQuery {
+  @Query(returns => IdRule, { nullable: true })
+  async idRule(@Arg('type') type: string, @Ctx() context: any): Promise<IdRule> {
+    const rule = await getRepository(IdRule).findOne({
+      where: {
+        domain: { id: context.state.domain.id },
+        type: type as any
+      }
+    })
+
+    return rule
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() idRule: IdRule) {
+    return await getRepository(Domain).findOneBy({ id: idRule.domainId })
+  }
+}

package/server/service/id-rule/id-rule-types.ts

@@ -0,0 +1,20 @@
+import { Field, InputType } from 'type-graphql'
+
+
+@InputType()
+export class IdRulePatch {
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  rule?: string
+}
+
+@InputType()
+export class NewIdRule {
+  @Field()
+  type: string
+
+  @Field()
+  rule: string
+}

package/server/service/id-rule/id-rule.ts

@@ -0,0 +1,49 @@
+import {
+  Field,
+  ID,
+  ObjectType
+} from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { Domain } from '@things-factory/shell'
+
+@Entity()
+@Index('ix_id_rule_1', (idRule: IdRule) => [idRule.domain])
+@ObjectType()
+export class IdRule {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain: Domain
+
+  @RelationId((idRule: IdRule) => idRule.domain)
+  domainId: string
+
+  @Column()
+  @Field({ nullable: true })
+  type: string
+
+  @Column()
+  @Field()
+  rule: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+}

package/server/service/id-rule/index.ts

@@ -0,0 +1,6 @@
+import { IdRule } from './id-rule'
+import { IdRuleMutation } from './id-rule-mutation'
+import { IdRuleQuery } from './id-rule-query'
+
+export const entities = [IdRule]
+export const resolvers = [IdRuleQuery, IdRuleMutation]

package/server/service/index.ts

@@ -0,0 +1,16 @@
+import { entities as IdRuleEntities, resolvers as IdRuleResolvers } from './id-rule'
+import { entities as SequenceEntities, resolvers as SequenceResolvers } from './sequence'
+import { entities as DocNumberEntities, resolvers as DocNumberResolvers } from './doc-number'
+
+/* EXPORT ENTITY TYPES */
+export * from './id-rule/id-rule'
+/* EXPORT TYPES */
+export * from './id-rule/id-rule-types'
+export * from './sequence/sequence'
+export * from './doc-number/doc-number'
+
+export const entities = [...IdRuleEntities, ...SequenceEntities, ...DocNumberEntities]
+
+export const schema = {
+  resolverClasses: [...IdRuleResolvers, ...SequenceResolvers, ...DocNumberResolvers]
+}

package/server/service/sequence/index.ts

@@ -0,0 +1,5 @@
+import { Sequence } from './sequence'
+import { SequenceMutation } from './sequence-mutation'
+
+export const entities = [Sequence]
+export const resolvers = [SequenceMutation]

package/server/service/sequence/sequence-mutation.ts

@@ -0,0 +1,56 @@
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
+
+import { getRepository } from '@things-factory/shell'
+
+import { SEQUENCE_TYPE } from '../../constants'
+import { Sequence } from './sequence'
+
+@Resolver(Sequence)
+export class SequenceMutation {
+  @Mutation(returns => Sequence)
+  async upsertSequence(
+    @Arg('type') type: string,
+    @Arg('counter') counter: number,
+    @Arg('bizplaceId') bizplaceId: string,
+    @Ctx() context: any
+  ) {
+    const { domain } = context.state
+    const seqRepo = getRepository(Sequence)
+    const now = new Date()
+    const expiresAt = new Date(now.setMonth(now.getMonth() + 12))
+
+    const patternObj: any = {
+      type,
+      date: new Date().toISOString().split('T')[0],
+      bizplaceId
+    }
+
+    const pattern: string = JSON.stringify(patternObj)
+
+    const foundSeq = await seqRepo.findOne({
+      where: { pattern, type: SEQUENCE_TYPE.PRODUCT_LABEL_COUNTER, domain: { id: domain.id } }
+    })
+
+    if (foundSeq) {
+      await seqRepo.update(
+        { id: foundSeq.id },
+        {
+          pattern,
+          seq: counter ? foundSeq.seq + counter : foundSeq.seq + 1,
+          expiresAt,
+          updatedAt: now
+        }
+      )
+
+      return await seqRepo.findOneBy({ id: foundSeq.id })
+    } else {
+      return await seqRepo.save({
+        domain,
+        pattern,
+        seq: counter || 1,
+        expiresAt,
+        type: SEQUENCE_TYPE.PRODUCT_LABEL_COUNTER
+      })
+    }
+  }
+}

package/server/service/sequence/sequence.ts

@@ -0,0 +1,49 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+
+import { Domain } from '@things-factory/shell'
+
+@Entity()
+@Index('ix_sequence_0', (seq: Sequence) => [seq.domain, seq.pattern], { unique: true })
+@Index('ix_sequence_1', (seq: Sequence) => [seq.pattern])
+@Index('ix_sequence_2', (seq: Sequence) => [seq.expiresAt])
+@ObjectType()
+export class Sequence {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain: Domain
+
+  @RelationId((sequence: Sequence) => sequence.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  pattern: string
+
+  @Column({
+    type: 'smallint'
+  })
+  @Field()
+  seq: number
+
+  //// to differentiate between normal pattern sequence VS label counter ////
+  @Column({ nullable: true })
+  @Field()
+  type: string
+
+  @Column({ nullable: true })
+  @Field()
+  expiresAt: Date
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+}