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

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

@@ -1,181 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-
-import { Contact } from './contact'
-import { NewContact, ContactPatch } from './contact-type'
-
-@Resolver(Contact)
-export class ContactMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Contact, { description: 'To create new Contact' })
-  async createContact(@Arg('contact') contact: NewContact, @Ctx() context: ResolverContext): Promise<Contact> {
-    const { domain, user, tx } = context.state
-    const file = contact.profile?.file
-
-    if (contact.profile) {
-      const { left, top, zoom } = contact.profile
-      contact.profile = { left, top, zoom }
-    }
-
-    const ContactRepository = tx.getRepository(Contact)
-
-    const result = await ContactRepository.save({
-      ...contact,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    if (file) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file,
-            refType: Contact.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Contact, { description: 'To modify Contact information' })
-  async updateContact(
-    @Arg('id') id: string,
-    @Arg('patch') patch: ContactPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Contact> {
-    const { domain, user, tx } = context.state
-    const file = patch.profile?.file
-
-    if (patch.profile) {
-      const { left, top, zoom } = patch.profile
-      patch.profile = { left, top, zoom } as any
-    }
-
-    const ContactRepository = tx.getRepository(Contact)
-
-    const contact = await ContactRepository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await ContactRepository.save({
-      ...contact,
-      ...patch,
-      updater: user
-    })
-
-    if (file) {
-      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file,
-            refType: Contact.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Contact], { description: "To modify multiple Contacts' information" })
-  async updateMultipleContact(
-    @Arg('patches', type => [ContactPatch]) patches: ContactPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Contact[]> {
-    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 contactRepo = tx.getRepository(Contact)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await contactRepo.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 contact = await contactRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await contactRepo.save({
-          ...contact,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Contact' })
-  async deleteContact(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Contact).softDelete({ domain: { id: domain.id }, id })
-    // await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Contacts' })
-  async deleteContacts(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Contact).softDelete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    // await deleteAttachmentsByRef(null, { refBys: ids }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple Contacts' })
-  async importContacts(
-    @Arg('contacts', type => [ContactPatch]) contacts: ContactPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      contacts.map(async (contact: ContactPatch) => {
-        const createdContact: Contact = await tx.getRepository(Contact).save({ domain, ...contact })
-      })
-    )
-
-    return true
-  }
-}

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

@@ -1,112 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx } from 'type-graphql'
-import { GraphQLEmailAddress } from 'graphql-scalars'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Attachment } from '@things-factory/attachment-base'
-import { Contact, ContactField } from './contact'
-import { ContactItem } from './contact-item'
-import { Profile } from './profile'
-import { ContactList } from './contact-type'
-
-function getContactItems(contact: Contact) {
-  const { items } = contact
-
-  if (!items || !(items instanceof Array)) {
-    return []
-  }
-
-  return items
-}
-
-function getContactItem(contact: Contact, type: String, label: String) {
-  const { items } = contact
-
-  return items?.find(item => item.type === type && item.label === label)?.value
-}
-
-@Resolver(Contact)
-export class ContactQuery {
-  @Query(returns => Contact!, { nullable: true, description: 'To fetch a Contact' })
-  async contact(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Contact> {
-    const { domain } = context.state
-
-    return await getRepository(Contact).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => ContactList, { description: 'To fetch multiple Contacts' })
-  async contacts(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<ContactList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(Contact),
-      searchables: ['name', 'company', 'email', 'phone']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Profile)
-  async profile(@Root() contact: Contact): Promise<Profile> {
-    var { left, top, zoom } = contact.profile || {}
-
-    if (left === undefined || top === undefined || zoom === undefined) {
-      return
-    }
-
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: contact.domainId },
-        refType: Contact.name,
-        refBy: contact.id
-      }
-    })
-
-    return { left, top, zoom, picture: attachment?.fullpath }
-  }
-
-  @FieldResolver(type => String, { nullable: true })
-  async phone(@Root() contact: Contact): Promise<string> {
-    return getContactItem(contact, ContactField.Phone, 'work')
-  }
-
-  @FieldResolver(type => GraphQLEmailAddress, { nullable: true })
-  async email(@Root() contact: Contact): Promise<string> {
-    return getContactItem(contact, ContactField.Email, 'work')
-  }
-
-  @FieldResolver(type => String, { nullable: true })
-  async address(@Root() contact: Contact): Promise<string> {
-    return getContactItem(contact, ContactField.Address, 'work')
-  }
-
-  @FieldResolver(type => String, { nullable: true })
-  async department(@Root() contact: Contact): Promise<string> {
-    return getContactItem(contact, ContactField.Department, 'work')
-  }
-
-  @FieldResolver(type => [ContactItem])
-  async items(@Root() contact: Contact): Promise<ContactItem[]> {
-    return getContactItems(contact)
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() contact: Contact): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: contact.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() contact: Contact): Promise<User> {
-    return await getRepository(User).findOneBy({ id: contact.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() contact: Contact): Promise<User> {
-    return await getRepository(User).findOneBy({ id: contact.creatorId })
-  }
-}

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

@@ -1,81 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-import { GraphQLEmailAddress } from 'graphql-scalars'
-
-import { ProfileInput } from './profile'
-import { ContactItemPatch } from './contact-item'
-import { Contact } from './contact'
-
-@InputType()
-export class NewContact {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  company?: string
-
-  @Field(type => GraphQLEmailAddress, { nullable: true })
-  email?: string
-
-  @Field({ nullable: true })
-  phone?: string
-
-  @Field({ nullable: true })
-  address?: string
-
-  @Field({ nullable: true })
-  department?: string
-
-  @Field({ nullable: true })
-  note?: string
-
-  @Field(type => ProfileInput, { nullable: true })
-  profile?: ProfileInput
-
-  @Field(type => [ContactItemPatch], { nullable: true })
-  items?: ContactItemPatch[]
-}
-
-@InputType()
-export class ContactPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  company?: string
-
-  @Field(type => GraphQLEmailAddress, { nullable: true })
-  email?: string
-
-  @Field({ nullable: true })
-  phone?: string
-
-  @Field({ nullable: true })
-  address?: string
-
-  @Field({ nullable: true })
-  department?: string
-
-  @Field({ nullable: true })
-  note?: string
-
-  @Field(type => ProfileInput, { nullable: true })
-  profile?: ProfileInput
-
-  @Field(type => [ContactItemPatch], { nullable: true })
-  items?: ContactItemPatch[]
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class ContactList {
-  @Field(type => [Contact])
-  items: Contact[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/contact/contact.ts

@@ -1,117 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
-import { GraphQLEmailAddress } from 'graphql-scalars'
-
-import { Domain, ScalarObject } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-import { ContactItem } from './contact-item'
-import { Profile } from './profile'
-
-export enum ContactField {
-  Name = 'name',
-  JobTitle = 'job-title',
-  Phone = 'phone',
-  Address = 'address',
-  Email = 'email',
-  Birthday = 'birthday',
-  Profile = 'profile',
-  Picture = 'picture',
-  Department = 'department',
-  Company = 'company',
-  Homepage = 'homepage'
-}
-
-registerEnumType(ContactField, {
-  name: 'ContactField',
-  description: 'field enumeration of a contact'
-})
-
-@Entity()
-@Index('ix_contact_0', (contact: Contact) => [contact.domain, contact.name])
-@ObjectType({ description: 'Entity for Contact' })
-export class Contact {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((contact: Contact) => contact.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  company?: string
-
-  @Field(type => GraphQLEmailAddress, { nullable: true })
-  email?: string
-
-  @Field({ nullable: true })
-  phone?: string
-
-  @Field({ nullable: true })
-  address?: string
-
-  @Field({ nullable: true })
-  department?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  note?: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => Profile, { nullable: true })
-  profile: Profile
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ContactItem], { nullable: true })
-  items?: ContactItem[]
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((contact: Contact) => contact.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((contact: Contact) => contact.updater)
-  updaterId?: string
-
-  getContactItem(type: ContactField, label?: string) {
-    return (this.items || []).find(item => item.type === type && (!item.label || item.label === label))?.value
-  }
-}

package/server/service/contact/index.ts

@@ -1,7 +0,0 @@
-import { Contact } from './contact'
-import { Profile } from './profile'
-import { ContactQuery } from './contact-query'
-import { ContactMutation } from './contact-mutation'
-
-export const entities = [Profile, Contact]
-export const resolvers = [ContactQuery, ContactMutation]

package/server/service/contact/profile.ts

@@ -1,36 +0,0 @@
-import { ObjectType, Field, InputType } from 'type-graphql'
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-
-@ObjectType({ description: 'Object type for Profile' })
-export class Profile {
-  @Field({ nullable: true })
-  left?: number
-
-  @Field({ nullable: true })
-  top?: number
-
-  @Field({ nullable: true })
-  zoom?: number
-
-  @Field({ nullable: true })
-  picture?: string
-}
-
-@InputType({ description: 'Input type for Profile' })
-export class ProfileInput {
-  @Field({ nullable: true })
-  left?: number
-
-  @Field({ nullable: true })
-  top?: number
-
-  @Field({ nullable: true })
-  zoom?: number
-
-  @Field({ nullable: true })
-  picture?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  file?: FileUpload
-}

package/server/service/index.ts

@@ -1,23 +0,0 @@
-/* EXPORT ENTITY TYPES */
-export * from './contact/profile'
-export * from './contact/contact-item'
-export * from './contact/contact'
-
-/* IMPORT ENTITIES AND RESOLVERS */
-import { entities as ContactEntities, resolvers as ContactResolvers } from './contact'
-
-export const entities = [
-  /* ENTITIES */
-  ...ContactEntities
-]
-
-export const subscribers = [
-  /* SUBSCRIBERS */
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...ContactResolvers
-  ]
-}

package/server/tsconfig.json

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