@things-factory/biz-base 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,236 @@
+import { Arg, Args, Ctx, Directive, Query, Resolver } from 'type-graphql'
+import { EntityManager, FindManyOptions, In, Not, Repository } from 'typeorm'
+
+import { User, UserList } from '@things-factory/auth-base'
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import {
+  getMyBizplace,
+  getPartnerBizplaceIds,
+  getPartnersBizplaces,
+  getPartnersCompanyBizplaces,
+  getPermittedBizplaceIds,
+  getUserBizplaces
+} from '../../utils'
+import { Bizplace } from './bizplace'
+import { BizplaceList } from './bizplace-types'
+
+@Resolver(Bizplace)
+export class BizplaceQuery {
+  @Directive('@privilege(category: "bizplace", privilege: "query")')
+  @Query(returns => [Bizplace])
+  async customerBizplaces(@Ctx() context: ResolverContext): Promise<Bizplace[]> {
+    const { domain, user } = context.state
+    return await getRepository(Bizplace).find({
+      where: {
+        domain: { id: domain.id },
+        id: Not(In([await getMyBizplace(domain, user)]))
+      },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @Directive('@privilege(category: "bizplace", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Bizplace)
+  async businessBizplace(@Ctx() context: ResolverContext): Promise<Bizplace> {
+    const { domain, user } = context.state
+    const myBizplace = await getMyBizplace(domain, user)
+    return await getRepository(Bizplace).findOne({
+      where: { id: myBizplace.id },
+      relations: ['company', 'domain', 'users', 'creator', 'updater']
+    })
+  }
+
+  /* TODO make it work */
+  @Directive('@privilege(category: "bizplace", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => [Bizplace])
+  async userBizplaces(@Arg('email') email: string, @Ctx() context: ResolverContext): Promise<Bizplace[]> {
+    const { domain } = context.state
+
+    const user: User = await getRepository(User).findOneBy({
+      email: email != '' ? email : context.state.user.email
+    })
+
+    return await getUserBizplaces(user)
+
+    // const bizplaces = await getRepository(Bizplace).find({ domain })
+    // // const userBizplaces = user.bizplaces
+    // return bizplaces.map((bizplace: Bizplace) => {
+    //   return {
+    //     id: bizplace.id,
+    //     name: bizplace.name,
+    //     description: bizplace.description,
+    //     userBizplaceId: userBizplaces
+    //       .map(userBiz => userBiz.bizplace.id)
+    //       .slice(0, 1)
+    //       .shift(),
+    //     assigned: userBizplaces.filter((userBizplace: Bizplace) => userBizplace.id === bizplace.id).length > 0
+    //   }
+    // })
+  }
+
+  @Directive('@privilege(category: "bizplace", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => BizplaceList)
+  async bizplaces(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<BizplaceList> {
+    let bizplace_ids = []
+    let bizplaceIndex: any = params.filters.findIndex(x => x.name === 'bizplace')
+    if (bizplaceIndex > -1) {
+      bizplace_ids = params.filters
+        .filter(x => x.name === 'bizplace')
+        .map(item => {
+          return item.value
+        })
+      params.filters.splice(bizplaceIndex, 1)
+    }
+
+    const convertedParams = convertListParams(params)
+
+    let domainIndex: any = params.filters.findIndex(x => x.name === 'domain')
+    if (domainIndex > -1) {
+      convertedParams.where.id = In(await getPartnerBizplaceIds(context.state.domain, context.state.user))
+    } else {
+      if (!(bizplace_ids.length > 0))
+        convertedParams.where.id = In(await getPermittedBizplaceIds(context.state.domain, context.state.user))
+      else convertedParams.where.id = In(bizplace_ids)
+    }
+
+    const [items, total] = await getRepository(Bizplace).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'company', 'users', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "bizplace", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Bizplace)
+  async bizplace(@Arg('id') id: string): Promise<Bizplace> {
+    return await getRepository(Bizplace).findOne({
+      where: { id },
+      relations: ['company', 'domain', 'users', 'users.roles', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => UserList)
+  async bizplaceUsers(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<UserList> {
+    const { domain, user } = context.state
+    const myBizplace: Bizplace = await getMyBizplace(domain, user)
+    return await bizplaceUsers(myBizplace, {
+      ...(await convertListParams(params)),
+      relations: ['domain', 'domains', 'roles', 'roles.privileges', 'roles.users']
+    })
+  }
+
+  @Query(returns => BizplaceList)
+  async partnersBizplaces(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<BizplaceList> {
+    let partnersBizplaceIds = []
+    let bizplaceIndex: any = params.filters.findIndex(x => x.name === 'bizplace')
+    if (bizplaceIndex > -1) {
+      partnersBizplaceIds = params.filters
+        .filter(x => x.name === 'bizplace')
+        .map(item => {
+          return item.value
+        })
+      params.filters.splice(bizplaceIndex, 1)
+    }
+
+    if (!(partnersBizplaceIds.length > 0)) {
+      const partnersBizplaces: Bizplace[] = await getPartnersBizplaces(context.state.domain, context.state.user)
+      partnersBizplaceIds = partnersBizplaces.map((bizplace: Bizplace) => bizplace.id || null)
+      params.filters.push({
+        name: 'id',
+        operator: 'in',
+        value: partnersBizplaceIds
+      })
+    } else {
+      params.filters.push({
+        name: 'id',
+        operator: 'in',
+        value: partnersBizplaceIds
+      })
+    }
+
+    const convertedParams = convertListParams(params, {
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await getRepository(Bizplace).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'company', 'users', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @Query(returns => BizplaceList)
+  async permittedPartnersCompanyBizplaces(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<BizplaceList> {
+    let partnersBizplaceIds = []
+    let bizplaceIndex: any = params.filters.findIndex(x => x.name === 'bizplace')
+    if (bizplaceIndex > -1) {
+      partnersBizplaceIds = params.filters
+        .filter(x => x.name === 'bizplace')
+        .map(item => {
+          return item.value
+        })
+      params.filters.splice(bizplaceIndex, 1)
+    }
+
+    const convertedParams = convertListParams(params)
+
+    if (!(partnersBizplaceIds.length > 0)) {
+      const partnersBizplaces: Bizplace[] = await getPartnersCompanyBizplaces(
+        context.state.domain,
+        context.state.user,
+        true
+      )
+      partnersBizplaceIds = partnersBizplaces.map((bizplace: Bizplace) => bizplace.id || null)
+      convertedParams.where.id = In(partnersBizplaceIds)
+    } else {
+      convertedParams.where.id = In(partnersBizplaceIds)
+    }
+
+    const [items, total] = await getRepository(Bizplace).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'company', 'users', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+}
+
+export async function bizplaceUsers(
+  bizplace: Bizplace,
+  params: FindManyOptions<User>,
+  trxMgr?: EntityManager
+): Promise<{ items: User[]; total: number }> {
+  const bizplaceRepo: Repository<Bizplace> = trxMgr?.getRepository(Bizplace) || getRepository(Bizplace)
+  const userRepo: Repository<User> = trxMgr?.getRepository(User) || getRepository(User)
+
+  if (!bizplace?.users?.length) {
+    bizplace = await bizplaceRepo.findOne({
+      where: { id: bizplace.id },
+      relations: ['users']
+    })
+  }
+  const users: User[] = bizplace.users
+  const userIds: string[] = users.map((user: User) => user.id)
+
+  const [items, total] = await userRepo.findAndCount({
+    ...params,
+    where: {
+      ...(params.where as any),
+      id: In(userIds)
+    }
+  })
+
+  return {
+    items,
+    total
+  }
+}

package/server/service/bizplace/bizplace-types.ts

@@ -0,0 +1,89 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { Bizplace } from './bizplace'
+
+@ObjectType()
+export class BizplaceList {
+  @Field(type => [Bizplace], { nullable: true })
+  items?: Bizplace[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@ObjectType()
+export class UserBizplace {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  assigned?: boolean
+
+  @Field({ nullable: true })
+  userBizplaceId?: string
+
+  @Field({ nullable: true })
+  mainBizplace?: boolean
+}
+
+@InputType()
+export class BizplacePatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  company?: ObjectRef
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  address?: string
+
+  @Field({ nullable: true })
+  postalCode?: string
+
+  @Field({ nullable: true })
+  latlng?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@InputType()
+export class NewBizplace {
+  @Field()
+  name: string
+
+  @Field()
+  company: ObjectRef
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field()
+  address: string
+
+  @Field()
+  postalCode: string
+
+  @Field()
+  latlng: string
+
+  @Field({ nullable: true })
+  status?: string
+}

package/server/service/bizplace/bizplace.ts

@@ -0,0 +1,108 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { BizOption } from '../biz-option/biz-option'
+import { Company } from '../company/company'
+
+@Entity()
+@Index('ix_bizplaces_0', (bizplace: Bizplace) => [bizplace.name], { unique: true })
+@Index('ix_bizplaces_1', (company: Company) => [company.domain], { unique: false })
+@ObjectType()
+export class Bizplace {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @OneToMany(type => BizOption, bizOption => bizOption.bizplace)
+  @Field(type => [BizOption], { nullable: true })
+  bizOptions: BizOption[]
+
+  @ManyToMany(type => User)
+  @JoinTable({ name: 'bizplaces_users' })
+  @Field(type => [User])
+  users: User[]
+
+  @ManyToOne(type => Company)
+  @Field(type => Company)
+  company: Company
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description: string
+
+  @Column()
+  @Field()
+  address: string
+
+  @Column()
+  @Field()
+  postalCode: string
+
+  @Column()
+  @Field()
+  latlng: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  status: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater: User
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+
+  constructor(obj?) {
+    if (obj) {
+      this.id = obj.Bizplace_id
+      this.name = obj.Bizplace_name
+      this.description = obj.Bizplace_description
+      this.address = obj.Bizplace_address
+      this.postalCode = obj.Bizplace_postal_code
+      this.latlng = obj.Bizplace_latlng
+      this.status = obj.Bizplace_status
+      this.createdAt = obj.Bizplace_created_at
+      this.updatedAt = obj.Bizplace_updated_at
+    }
+  }
+}

package/server/service/bizplace/index.ts

@@ -0,0 +1,6 @@
+import { Bizplace } from './bizplace'
+import { BizplaceMutation } from './bizplace-mutation'
+import { BizplaceQuery } from './bizplace-query'
+
+export const entities = [Bizplace]
+export const resolvers = [BizplaceQuery, BizplaceMutation]

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

@@ -0,0 +1,122 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getRepository } from '@things-factory/shell'
+import { slugger } from '@things-factory/utils'
+
+import { Company } from './company'
+import { CompanyPatch, NewCompany } from './company-types'
+
+@Resolver(Company)
+export class CompanyMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Company)
+  async createCompany(@Arg('company') company: NewCompany, @Ctx() context: ResolverContext): Promise<Company> {
+    const { domain, user, tx } = context.state
+    return await createCompany(company, domain, user, tx)
+  }
+
+  @Directive('@privilege(category: "company", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Company)
+  async updateCompany(
+    @Arg('name') name: string,
+    @Arg('patch') patch: CompanyPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Company> {
+    const { domain, user, tx } = context.state
+    return await updateCompany(name, patch, domain, user, tx)
+  }
+
+  @Directive('@privilege(category: "company", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Company])
+  async updateMultipleCompany(
+    @Arg('patches', type => [CompanyPatch]) patches: CompanyPatch[],
+    @Ctx() context: ResolverContext
+  ) {
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const patch: CompanyPatch = _createRecords[i]
+        const result = await this.createCompany(patch as NewCompany, context)
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const patch: CompanyPatch = _updateRecords[i]
+        const result = await this.updateCompany(patch.name, patch, context)
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteCompany(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    await deleteCompany(id, context.state.tx)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "company", privilege: "mutation")')
+  @Mutation(returns => Boolean)
+  async deleteCompanies(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    await deleteCompanies(ids, context.state.tx)
+
+    return true
+  }
+}
+
+export async function createCompany(company: NewCompany, domain: Domain, user: User, tx?: EntityManager) {
+  const companyRepository: Repository<Company> = tx ? tx.getRepository(Company) : getRepository(Company)
+  const domainRepository: Repository<Domain> = tx ? tx.getRepository(Domain) : getRepository(Domain)
+
+  const companyDomain: Domain = await domainRepository.save({
+    subdomain: slugger(company.name),
+    name: company.name
+  })
+
+  return await companyRepository.save({
+    ...company,
+    domain: companyDomain,
+    creator: user,
+    updater: user
+  })
+}
+
+export async function updateCompany(name: string, patch: CompanyPatch, domain: Domain, user: User, tx?: EntityManager) {
+  const repository: Repository<Company> = tx ? tx.getRepository(Company) : getRepository(Company)
+  const company = await repository.findOneBy({
+    domain: { id: domain.id },
+    name
+  })
+
+  return repository.save({
+    ...company,
+    ...patch,
+    updater: user
+  })
+}
+
+export async function deleteCompanies(ids: string[], tx?: EntityManager) {
+  const repository = tx ? tx.getRepository(Company) : getRepository(Company)
+  return await repository.delete(ids)
+}
+
+export async function deleteCompany(id: string, tx?: EntityManager) {
+  const repository: Repository<Company> = tx ? tx.getRepository(Company) : getRepository(Company)
+  return await repository.delete(id)
+}

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

@@ -0,0 +1,70 @@
+import { Args, Ctx, Directive, Query, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { getDomainUsers, getUserDomains, User, UserList } from '@things-factory/auth-base'
+import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
+
+import { Bizplace } from '../bizplace/bizplace'
+import { BizplaceList } from '../bizplace/bizplace-types'
+import { Company } from './company'
+import { CompanyList } from './company-types'
+
+@Resolver(Company)
+export class CompanyQuery {
+  @Directive('@privilege(category: "company", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Company)
+  async company(@Ctx() context: ResolverContext): Promise<Company> {
+    const { domain } = context.state
+
+    const foundCompany: Company | null = await getRepository(Company).findOneBy({
+      domain: { id: domain.id }
+    })
+
+    if (!foundCompany) throw new Error(context.t('error.no x found', { x: context.t('field.company') }))
+    return foundCompany
+  }
+
+  @Directive('@privilege(category: "company", privilege: "query")')
+  @Query(returns => CompanyList)
+  async companies(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<CompanyList> {
+    const { domain } = context.state
+    const convertedParams = convertListParams(params, { domain })
+
+    const [items, total] = await getRepository(Company).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "company", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => BizplaceList)
+  async companyBizplaces(@Ctx() context: ResolverContext): Promise<BizplaceList> {
+    const { domain, user } = context.state
+
+    const userDomains: Partial<Domain>[] = await getUserDomains(user)
+    const company: Company = await getRepository(Company).findOneBy({
+      domain: { id: domain.id }
+    })
+
+    const [items, total] = await getRepository(Bizplace).findAndCount({
+      where: { company: { id: company.id }, domain: { id: In(userDomains.map(({ id }: Domain) => id)) } },
+      relations: ['domain']
+    })
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "company", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => UserList)
+  async companyUsers(@Ctx() context: ResolverContext): Promise<UserList> {
+    const { domain } = context.state
+
+    const items: User[] = await getDomainUsers(domain)
+
+    return {
+      items,
+      total: items.length
+    }
+  }
+}

package/server/service/company/company-types.ts

@@ -0,0 +1,68 @@
+import { ObjectType, InputType, Field, Int } from 'type-graphql'
+import { Company } from './company'
+
+@ObjectType()
+export class CompanyList {
+  @Field(type => [Company], { nullable: true })
+  items?: Company[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class CompanyPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  countryCode?: string
+
+  @Field({ nullable: true })
+  brn?: string
+
+  @Field({ nullable: true })
+  address?: string
+
+  @Field({ nullable: true })
+  postalCode?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@InputType()
+export class NewCompany {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field()
+  countryCode: string
+
+  @Field()
+  brn: string
+
+  @Field()
+  address: string
+
+  @Field({ nullable: true })
+  postalCode: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field()
+  status: string
+}