@things-factory/geography 8.0.0-beta.9 → 8.0.2

package/server/service/geo-state/geo-state-mutation.ts

@@ -0,0 +1,110 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { GeoState } from './geo-state'
+import { GeoStatePatch, NewGeoState } from './geo-state-type'
+
+@Resolver(GeoState)
+export class GeoStateMutation {
+  @Directive('@transaction')
+  @Mutation(returns => GeoState, { description: 'To create new GeoState' })
+  async createGeoState(@Arg('geoState') geoState: NewGeoState, @Ctx() context: ResolverContext): Promise<GeoState> {
+    const { user, tx } = context.state
+
+    return await tx.getRepository(GeoState).save({
+      ...geoState,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => GeoState, { description: 'To modify GeoState information' })
+  async updateGeoState(
+    @Arg('id') id: string,
+    @Arg('patch') patch: GeoStatePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<GeoState> {
+    const { user, tx } = context.state
+
+    const repository = tx.getRepository(GeoState)
+    const geoState = await repository.findOne({
+      where: { id }
+    })
+
+    return await repository.save({
+      ...geoState,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [GeoState], { description: "To modify multiple GeoStates' information" })
+  async updateMultipleGeoState(
+    @Arg('patches', type => [GeoStatePatch]) patches: GeoStatePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<GeoState[]> {
+    const { user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const geoStateRepo = tx.getRepository(GeoState)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await geoStateRepo.save({
+          ...newRecord,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const geoState = await geoStateRepo.findOneBy({ id: newRecord.id })
+
+        const result = await geoStateRepo.save({
+          ...geoState,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete GeoState' })
+  async deleteGeoState(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx } = context.state
+
+    await tx.getRepository(GeoState).delete({ id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple geoStates' })
+  async deleteGeoStates(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx } = context.state
+
+    await tx.getRepository(GeoState).delete({
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/geo-state/geo-state-query.ts

@@ -0,0 +1,41 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { GeoCountry } from '../geo-country/geo-country'
+import { GeoState } from './geo-state'
+import { GeoStateList } from './geo-state-type'
+
+@Resolver(GeoState)
+export class GeoStateQuery {
+  @Query(returns => GeoState, { description: 'To fetch a GeoState' })
+  async geoState(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GeoState> {
+    return await getRepository(GeoState).findOne({
+      where: { id }
+    })
+  }
+
+  @Query(returns => GeoStateList, { description: 'To fetch multiple GeoStates' })
+  async geoStates(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<GeoStateList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(GeoState).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => GeoCountry)
+  async geoCountry(@Root() geoState: GeoState): Promise<GeoCountry> {
+    return await getRepository(GeoCountry).findOneBy({ id: geoState.geoCountryId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() geoState: GeoState): Promise<User> {
+    return await getRepository(User).findOneBy({ id: geoState.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() geoState: GeoState): Promise<User> {
+    return await getRepository(User).findOneBy({ id: geoState.creatorId })
+  }
+}

package/server/service/geo-state/geo-state-type.ts

@@ -0,0 +1,47 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { GeoState } from './geo-state'
+
+@InputType()
+export class NewGeoState {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  latitude?: string
+
+  @Field({ nullable: true })
+  longitude?: string
+}
+
+@InputType()
+export class GeoStatePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  latitude?: string
+
+  @Field({ nullable: true })
+  longitude?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class GeoStateList {
+  @Field(type => [GeoState])
+  items: GeoState[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/geo-state/geo-state.ts

@@ -0,0 +1,73 @@
+import { User } from '@things-factory/auth-base'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { GeoCountry } from '../geo-country/geo-country'
+
+@Entity()
+@Index('ix_geo_state_0', (geoState: GeoState) => [geoState.geoCountry, geoState.name], { unique: true })
+@ObjectType({ description: 'Entity for GeoState' })
+export class GeoState {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => GeoCountry)
+  @Field()
+  geoCountry: GeoCountry
+
+  @RelationId((geoState: GeoState) => geoState.geoCountry)
+  geoCountryId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  latitude?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  longitude?: 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((geoState: GeoState) => geoState.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((geoState: GeoState) => geoState.updater)
+  updaterId?: string
+}

package/server/service/geo-state/index.ts

@@ -0,0 +1,6 @@
+import { GeoState } from './geo-state'
+import { GeoStateQuery } from './geo-state-query'
+import { GeoStateMutation } from './geo-state-mutation'
+
+export const entities = [GeoState]
+export const resolvers = [GeoStateQuery, GeoStateMutation]

package/server/service/index.ts

@@ -0,0 +1,33 @@
+/* EXPORT ENTITY TYPES */
+export * from './geo-area/geo-area'
+export * from './geo-city/geo-city'
+export * from './geo-state/geo-state'
+export * from './geo-country/geo-country'
+export * from './geo-continent/geo-continent'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as GeoAreaEntities, resolvers as GeoAreaResolvers } from './geo-area'
+import { entities as GeoCityEntities, resolvers as GeoCityResolvers } from './geo-city'
+import { entities as GeoStateEntities, resolvers as GeoStateResolvers } from './geo-state'
+import { entities as GeoCountryEntities, resolvers as GeoCountryResolvers } from './geo-country'
+import { entities as GeoContinentEntities, resolvers as GeoContinentResolvers } from './geo-continent'
+
+export const entities = [
+  /* ENTITIES */
+  ...GeoAreaEntities,
+  ...GeoCityEntities,
+  ...GeoStateEntities,
+  ...GeoCountryEntities,
+  ...GeoContinentEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...GeoAreaResolvers,
+    ...GeoCityResolvers,
+    ...GeoStateResolvers,
+    ...GeoCountryResolvers,
+    ...GeoContinentResolvers
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig-base.json",
+  "compilerOptions": {
+    "outDir": "./dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./server/**/*"],
+  "exclude": ["**/*.spec.ts"]
+}