@things-factory/calendar 8.0.0 → 9.0.0-beta.3

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

@@ -1,133 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Calendar } from './calendar'
-import { NewCalendar, CalendarPatch } from './calendar-type'
-
-@Resolver(Calendar)
-export class CalendarMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Calendar, { description: 'To create new Calendar' })
-  async createCalendar(@Arg('calendar') calendar: NewCalendar, @Ctx() context: ResolverContext): Promise<Calendar> {
-    const { domain, user, tx } = context.state
-
-    const result = await tx.getRepository(Calendar).save({
-      ...calendar,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Calendar, { description: 'To modify Calendar information' })
-  async updateCalendar(
-    @Arg('id') id: string,
-    @Arg('patch') patch: CalendarPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Calendar> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Calendar)
-    const calendar = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    return await repository.save({
-      ...calendar,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Calendar], { description: "To modify multiple Calendars' information" })
-  async updateMultipleCalendar(
-    @Arg('patches', type => [CalendarPatch]) patches: CalendarPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Calendar[]> {
-    const { domain, 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 calendarRepo = tx.getRepository(Calendar)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await calendarRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const calendar = await calendarRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await calendarRepo.save({
-          ...calendar,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Calendar' })
-  async deleteCalendar(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Calendar).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Calendars' })
-  async deleteCalendars(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Calendar).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple Calendars' })
-  async importCalendars(
-    @Arg('calendars', type => [CalendarPatch]) calendars: CalendarPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      calendars.map(async (calendar: CalendarPatch) => {
-        const createdCalendar: Calendar = await tx.getRepository(Calendar).save({ domain, ...calendar })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/calendar/calendar-query.ts

@@ -1,48 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Calendar } from './calendar'
-import { CalendarList } from './calendar-type'
-
-@Resolver(Calendar)
-export class CalendarQuery {
-  @Query(returns => Calendar!, { nullable: true, description: 'To fetch a Calendar' })
-  async calendar(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Calendar> {
-    const { domain } = context.state
-
-    return await getRepository(Calendar).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => CalendarList, { description: 'To fetch multiple Calendars' })
-  async calendars(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<CalendarList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Calendar),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() calendar: Calendar): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: calendar.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() calendar: Calendar): Promise<User> {
-    return await getRepository(User).findOneBy({ id: calendar.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() calendar: Calendar): Promise<User> {
-    return await getRepository(User).findOneBy({ id: calendar.creatorId })
-  }
-}

package/server/service/calendar/calendar-type.ts

@@ -1,55 +0,0 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { ObjectRef, ScalarObject } from '@things-factory/shell'
-
-import { Calendar, CalendarStatus } from './calendar'
-
-@InputType()
-export class NewCalendar {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => CalendarStatus, { nullable: true })
-  state?: CalendarStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  params?: string
-}
-
-@InputType()
-export class CalendarPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => CalendarStatus, { nullable: true })
-  state?: CalendarStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class CalendarList {
-  @Field(type => [Calendar])
-  items: Calendar[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/calendar/calendar.ts

@@ -1,82 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-export enum CalendarStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B'
-}
-
-registerEnumType(CalendarStatus, {
-  name: 'CalendarStatus',
-  description: 'state enumeration of a calendar'
-})
-
-@Entity()
-@Index('ix_calendar_0', (calendar: Calendar) => [calendar.domain, calendar.name], { unique: true })
-@ObjectType({ description: 'Entity for Calendar' })
-export class Calendar {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((calendar: Calendar) => calendar.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: CalendarStatus
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  params?: 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((calendar: Calendar) => calendar.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((calendar: Calendar) => calendar.updater)
-  updaterId?: string
-}

package/server/service/calendar/index.ts

@@ -1,7 +0,0 @@
-import { Calendar } from './calendar'
-import { CalendarQuery } from './calendar-query'
-import { CalendarMutation } from './calendar-mutation'
-
-export const entities = [Calendar]
-export const resolvers = [CalendarQuery, CalendarMutation]
-export const subscribers = []

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

@@ -1,125 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Event } from './event'
-import { NewEvent, EventPatch } from './event-type'
-
-@Resolver(Event)
-export class EventMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Event, { description: 'To create new Event' })
-  async createEvent(@Arg('event') event: NewEvent, @Ctx() context: ResolverContext): Promise<Event> {
-    const { user, tx } = context.state
-
-    return await tx.getRepository(Event).save({
-      ...event,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Event, { description: 'To modify Event information' })
-  async updateEvent(
-    @Arg('id') id: string,
-    @Arg('patch') patch: EventPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Event> {
-    const { user, tx } = context.state
-
-    const repository = tx.getRepository(Event)
-    const event = await repository.findOne({
-      where: { id }
-    })
-
-    return await repository.save({
-      ...event,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Event], { description: "To modify multiple Events' information" })
-  async updateMultipleEvent(
-    @Arg('patches', type => [EventPatch]) patches: EventPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Event[]> {
-    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 eventRepo = tx.getRepository(Event)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await eventRepo.save({
-          ...newRecord,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const event = await eventRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await eventRepo.save({
-          ...event,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Event' })
-  async deleteEvent(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx } = context.state
-
-    await tx.getRepository(Event).delete({ id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Events' })
-  async deleteEvents(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx } = context.state
-
-    await tx.getRepository(Event).delete({
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple Events' })
-  async importEvents(
-    @Arg('events', type => [EventPatch]) events: EventPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { tx } = context.state
-
-    await Promise.all(
-      events.map(async (event: EventPatch) => {
-        const createdEvent: Event = await tx.getRepository(Event).save({ ...event })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/event/event-query.ts

@@ -1,38 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Event } from './event'
-import { EventList } from './event-type'
-
-@Resolver(Event)
-export class EventQuery {
-  @Query(returns => Event!, { nullable: true, description: 'To fetch a Event' })
-  async event(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Event> {
-    return await getRepository(Event).findOne({
-      where: { id }
-    })
-  }
-
-  @Query(returns => EventList, { description: 'To fetch multiple Events' })
-  async events(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<EventList> {
-    const queryBuilder = getQueryBuilderFromListParams({
-      params,
-      repository: await getRepository(Event),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() event: Event): Promise<User> {
-    return await getRepository(User).findOneBy({ id: event.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() event: Event): Promise<User> {
-    return await getRepository(User).findOneBy({ id: event.creatorId })
-  }
-}

package/server/service/event/event-type.ts

@@ -1,61 +0,0 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { ObjectRef, ScalarObject } from '@things-factory/shell'
-
-import { Event, EventStatus } from './event'
-
-@InputType()
-export class NewEvent {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => EventStatus, { nullable: true })
-  state?: EventStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  params?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-}
-
-@InputType()
-export class EventPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => EventStatus, { nullable: true })
-  state?: EventStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class EventList {
-  @Field(type => [Event])
-  items: Event[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/event/event.ts

@@ -1,85 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  ManyToMany,
-  JoinTable,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { Attendee } from '../attendee/attendee'
-
-export enum EventStatus {
-  STATUS_A = 'STATUS_A',
-  STATUS_B = 'STATUS_B'
-}
-
-registerEnumType(EventStatus, {
-  name: 'EventStatus',
-  description: 'state enumeration of a event'
-})
-
-@Entity()
-@ObjectType({ description: 'Entity for Event' })
-export class Event {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ type: 'datetime' })
-  @Field({ nullable: true })
-  startDateTime: Date
-
-  @Column({ type: 'datetime' })
-  @Field({ nullable: true })
-  endDateTime: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  location: string
-
-  @ManyToMany(() => Attendee)
-  @JoinTable()
-  @Field(type => [Attendee], { nullable: true })
-  attendees: Attendee[]
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: EventStatus
-
-  @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((event: Event) => event.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((event: Event) => event.updater)
-  updaterId?: string
-}

package/server/service/event/index.ts

@@ -1,7 +0,0 @@
-import { Event } from './event'
-import { EventQuery } from './event-query'
-import { EventMutation } from './event-mutation'
-
-export const entities = [Event]
-export const resolvers = [EventQuery, EventMutation]
-export const subscribers = []

package/server/service/index.ts

@@ -1,32 +0,0 @@
-/* EXPORT ENTITY TYPES */
-export * from './attendee/attendee'
-export * from './event/event'
-export * from './calendar/calendar'
-
-/* IMPORT ENTITIES AND RESOLVERS */
-import { entities as AttendeeEntities, resolvers as AttendeeResolvers, subscribers as AttendeeSubscribers } from './attendee'
-import { entities as EventEntities, resolvers as EventResolvers, subscribers as EventSubscribers } from './event'
-import { entities as CalendarEntities, resolvers as CalendarResolvers, subscribers as CalendarSubscribers } from './calendar'
-
-export const entities = [  
-  /* ENTITIES */
-	...AttendeeEntities,
-	...EventEntities,
-	...CalendarEntities,
-] 
-
-export const subscribers = [
-  /* SUBSCRIBERS */
-	...AttendeeSubscribers,
-	...EventSubscribers,
-	...CalendarSubscribers,
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-		...AttendeeResolvers,
-		...EventResolvers,
-		...CalendarResolvers,
-  ] 
-}

package/server/tsconfig.json

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