New Integration: Zendesk

engine-idk/src/common_models/ticketing/account.ts

@@ -0,0 +1,9 @@
+/** Copyright (c) 2023, Poozle, all rights reserved. **/
+
+export interface Account {
+  id: string;
+  name: string;
+  domains: string[];
+  created_at: string;
+  updated_at: string;
+}

engine-idk/src/common_models/ticketing/index.ts

@@ -1,5 +1,6 @@
 /** Copyright (c) 2023, Poozle, all rights reserved. **/
 
+export * from './account';
 export * from './ticket';
 export * from './collection';
 export * from './comment';

engine-idk/src/common_models/ticketing/team.ts

@@ -10,6 +10,8 @@ export interface Team {
   name: string;
   description: string;
   members: Member[];
+  created_at: string;
+  updated_at: string;
 }
 
 export interface CreateTeamBody {

engine-idk/src/common_models/ticketing/ticket.ts

@@ -14,6 +14,7 @@ export interface Ticket {
   id: string;
   parent_id: string;
   collection_id: string;
+  organization_id: string;
   type: string;
   name: string;
   description: string;
@@ -37,6 +38,9 @@ export interface CreateTicketBody {
   tags: TicketTag[];
   created_by: string;
   type: string;
+  account_id: string;
+  priority: string;
+  status: string;
 }
 
 export interface UpdateTicketBody {

engine-idk/src/common_models/ticketing/user.ts

@@ -27,4 +27,7 @@ export interface User {
   name: string;
   email_address: string;
   avatar: string;
+  is_active: boolean;
+  created_at: string;
+  updated_at: string;
 }

engine-server/src/modules/categories/ticketing/models/account/account.controller.ts

@@ -0,0 +1,61 @@
+/** Copyright (c) 2023, Poozle, all rights reserved. **/
+
+import { Controller, Get, Param, Query, UseGuards } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { IntegrationType } from '@prisma/client';
+
+import { IntegrationAccount } from '@@generated/integrationAccount/entities';
+
+import { GetIntegrationAccount } from 'common/decorators/integration_account.decorator';
+
+import { AuthGuard } from 'modules/auth/auth.guard';
+
+import {
+  AccountQueryParams,
+  GetAccountQueryParams,
+  PathParamsWithAccountId,
+  TicketingAccountResponse,
+  TicketingAccountsResponse,
+} from './account.interface';
+import { AccountService } from './account.service';
+
+@Controller({
+  version: '1',
+  path: 'ticketing/accounts',
+})
+@ApiTags('Ticketing')
+export class AccountController {
+  constructor(private accountService: AccountService) {}
+
+  @Get()
+  @UseGuards(new AuthGuard())
+  async getAccounts(
+    @Query() query: AccountQueryParams,
+    @GetIntegrationAccount(IntegrationType.TICKETING)
+    integrationAccount: IntegrationAccount,
+  ): Promise<TicketingAccountsResponse> {
+    const accountResponse = await this.accountService.getAccounts(
+      integrationAccount,
+      query,
+    );
+
+    return accountResponse;
+  }
+
+  @Get(':account_id')
+  async getAccount(
+    @Query() query: GetAccountQueryParams,
+    @Param()
+    params: PathParamsWithAccountId,
+    @GetIntegrationAccount(IntegrationType.TICKETING)
+    integrationAccount: IntegrationAccount,
+  ): Promise<TicketingAccountResponse> {
+    const accountResponse = await this.accountService.getAccount(
+      integrationAccount,
+      query,
+      params,
+    );
+
+    return accountResponse;
+  }
+}

engine-server/src/modules/categories/ticketing/models/account/account.interface.ts

@@ -0,0 +1,58 @@
+/** Copyright (c) 2023, Poozle, all rights reserved. **/
+
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsOptional, IsString } from 'class-validator';
+
+import { JustRawParams, QueryParams } from 'common/interfaces/query.interface';
+import { Meta } from 'common/interfaces/response.interface';
+
+export class AccountQueryParams extends QueryParams {
+  @IsOptional()
+  @IsBoolean()
+  @Transform(({ value }) => {
+    return value === 'true' || value === 'True' || value === true;
+  })
+  realtime?: boolean = false;
+}
+
+export class GetAccountQueryParams extends JustRawParams {
+  @IsOptional()
+  @IsBoolean()
+  @Transform(({ value }) => {
+    return value === 'true' || value === 'True' || value === true;
+  })
+  realtime?: boolean = false;
+}
+
+export class Account {
+  id: string;
+  name: string;
+  domains: string[];
+  created_at: string;
+  updated_at: string;
+
+  integration_account_id?: string;
+}
+
+export const ACCOUNT_KEYS = [
+  'id',
+  'domains',
+  'name',
+  'description',
+  'updated_at',
+  'created_at',
+];
+
+export class TicketingAccountsResponse {
+  data: Account[];
+  meta: Meta;
+}
+
+export class TicketingAccountResponse {
+  data: Account;
+}
+
+export class PathParamsWithAccountId {
+  @IsString()
+  account_id: string;
+}

engine-server/src/modules/categories/ticketing/models/account/account.service.ts

@@ -0,0 +1,159 @@
+/* eslint-disable dot-location */
+/** Copyright (c) 2023, Poozle, all rights reserved. **/
+
+import { Injectable } from '@nestjs/common';
+import { Method } from 'shared/integration_account.utils';
+
+import { IntegrationAccount } from '@@generated/integrationAccount/entities';
+
+import {
+  applyDateFilter,
+  getBaseQuery,
+  getMetaParams,
+  getObjectFromDb,
+} from 'common/knex';
+import { pagination } from 'common/utils';
+
+import { DataService } from 'modules/data/data.service';
+
+import {
+  ACCOUNT_KEYS,
+  AccountQueryParams,
+  GetAccountQueryParams,
+  PathParamsWithAccountId,
+} from './account.interface';
+
+const DATABASE_NAME = 'ticketing_account';
+
+@Injectable()
+export class AccountService {
+  constructor(private dataService: DataService) {}
+
+  async getAccounts(
+    integrationAccount: IntegrationAccount,
+    query: AccountQueryParams,
+  ) {
+    if (query.realtime || !integrationAccount.syncEnabled) {
+      return await this.getAccountsForRealtime(integrationAccount, query);
+    }
+
+    return await this.getAccountsFromDb(integrationAccount, query);
+  }
+
+  async getAccount(
+    integrationAccount: IntegrationAccount,
+    query: GetAccountQueryParams,
+    params: PathParamsWithAccountId,
+  ) {
+    if (query.realtime || !integrationAccount.syncEnabled) {
+      return await this.getAccountForRealtime(
+        integrationAccount,
+        query,
+        params,
+      );
+    }
+
+    return await this.getAccountFromDb(integrationAccount, query, params);
+  }
+
+  async getListFromDb(
+    workspaceName: string,
+    table: string,
+    where: Record<string, string>,
+    SELECT_KEYS: string[],
+    queryParams: AccountQueryParams,
+  ) {
+    const { offset, limit, page } = pagination(
+      queryParams.limit,
+      queryParams.cursor,
+    );
+
+    let query = getBaseQuery(
+      workspaceName,
+      table,
+      where,
+      SELECT_KEYS,
+      queryParams.raw,
+    );
+
+    query = applyDateFilter(query, queryParams);
+
+    const data = await query.limit(limit).offset(offset);
+
+    return {
+      data,
+      meta: getMetaParams(data, limit, page),
+    };
+  }
+
+  async getAccountsFromDb(
+    integrationAccount: IntegrationAccount,
+    query: AccountQueryParams,
+  ) {
+    return await this.getListFromDb(
+      integrationAccount.workspaceName,
+      DATABASE_NAME,
+      {
+        integration_account_id: integrationAccount.integrationAccountId,
+      },
+      ACCOUNT_KEYS,
+      query,
+    );
+  }
+
+  async getAccountFromDb(
+    integrationAccount: IntegrationAccount,
+    query: GetAccountQueryParams,
+    params: PathParamsWithAccountId,
+  ) {
+    return await getObjectFromDb(
+      integrationAccount.workspaceName,
+      DATABASE_NAME,
+      {
+        integration_account_id: integrationAccount.integrationAccountId,
+        id: params.account_id,
+      },
+      ACCOUNT_KEYS,
+      query.raw,
+    );
+  }
+
+  async getAccountForRealtime(
+    integrationAccount: IntegrationAccount,
+    query: GetAccountQueryParams,
+    params: PathParamsWithAccountId,
+  ) {
+    const accountResponse = await this.dataService.getDataFromAccount(
+      integrationAccount,
+      `/accounts/${params.account_id}`,
+      Method.GET,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      { raw: query.raw },
+      params,
+    );
+
+    return accountResponse;
+  }
+
+  async getAccountsForRealtime(
+    integrationAccount: IntegrationAccount,
+    query: AccountQueryParams,
+  ) {
+    const accountResponse = await this.dataService.getDataFromAccount(
+      integrationAccount,
+      '/accounts',
+      Method.GET,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      {
+        limit: query.limit,
+        cursor: query.cursor,
+        raw: query.raw,
+        created_after: query.created_after,
+        created_before: query.created_before,
+      },
+      {},
+    );
+
+    return accountResponse;
+  }
+}