updateCompany

Instructions

Implementation Reference

• src/tools/companies/updateCompany.ts:110-138 (handler)

  Tool handler function that validates inputs (companyId, companyData) and calls the service layer to update a company.

  export async function handleUpdateCompany(input: any) {
    logger.info('Calling teamworkService.updateCompany()');
    logger.info(`Company ID: ${input?.companyId}`);
    
    try {
      const companyId = input.companyId;
      const companyData = input.companyRequest;
      
      if (!companyId) {
        throw new Error("Company ID is required");
      }
      
      if (!companyData) {
        throw new Error("Company data is required for update");
      }
      
      const result = await teamworkService.updateCompany(companyId, companyData);
      logger.info(`Company updated successfully with ID: ${companyId}`);
      
      return {
        content: [{
          type: "text",
          text: JSON.stringify(result, null, 2)
        }]
      };
    } catch (error: any) {
      return createErrorResponse(error, 'Updating company');
    }
  } 

• src/tools/companies/updateCompany.ts:11-107 (schema)

  Tool definition (updateCompanyDefinition) with inputSchema describing companyId (integer), companyRequest (object with fields like addressOne, city, company name, etc.), and options.

  export const updateCompanyDefinition = {
    name: "updateCompany",
    description: "This tool allows you to update a company. It requires parameters: companyId and companyRequest.",
    inputSchema: {
      type: 'object',
      properties: {
        companyId: {
          type: 'integer',
          description: 'Path parameter: companyId'
        },
        companyRequest: {
          type: 'object',
          properties: {
            addressOne: {
              type: 'string',
              description: 'First line of address'
            },
            addressTwo: {
              type: 'string',
              description: 'Second line of address'
            },
            city: {
              type: 'string',
              description: 'City'
            },
            company: {
              type: 'object',
              properties: {
                name: {
                  type: 'string',
                  description: 'Company name'
                }
              }
            },
            countryCode: {
              type: 'string',
              description: 'Country code'
            },
            emailOne: {
              type: 'string',
              description: 'First email address'
            },
            emailTwo: {
              type: 'string',
              description: 'Second email address'
            },
            fax: {
              type: 'string',
              description: 'Fax number'
            },
            name: {
              type: 'string',
              description: 'Company name'
            },
            phone: {
              type: 'string',
              description: 'Phone number'
            },
            state: {
              type: 'string',
              description: 'State'
            },
            tags: {
              type: 'array',
              items: {
                type: 'string'
              },
              description: 'List of tags'
            },
            website: {
              type: 'string',
              description: 'Website URL'
            },
            zip: {
              type: 'string',
              description: 'ZIP/Postal code'
            }
          }
        },
        options: {
          type: 'object',
          properties: {},
          description: 'Additional options for the request'
        }
      },
      required: [
        'companyId',
        'companyRequest'
      ]
    },
    annotations: {
      title: "Update Company",
      readOnlyHint: false,
      destructiveHint: false,
      openWorldHint: false
    }
  };

• src/tools/index.ts:39-90 (registration)

  Import and registration of updateCompany tool definition + handler in the toolPairs array.

  import { updateCompanyDefinition as updateCompany, handleUpdateCompany } from './companies/updateCompany.js';
  import { deleteCompanyDefinition as deleteCompany, handleDeleteCompany } from './companies/deleteCompany.js';
  import { getCompaniesDefinition as getCompanies, handleGetCompanies } from './companies/getCompanies.js';
  import { getCompanyByIdDefinition as getCompanyById, handleGetCompanyById } from './companies/getCompanyById.js';
  
  // Reporting
  import { getProjectsPeopleMetricsPerformanceDefinition as getProjectsPeopleMetricsPerformance, handleGetProjectsPeopleMetricsPerformance } from './people/getPeopleMetricsPerformance.js';
  import { getProjectsPeopleUtilizationDefinition as getProjectsPeopleUtilization, handleGetProjectsPeopleUtilization } from './people/getPeopleUtilization.js';
  import { getProjectPersonDefinition as getProjectPerson, handleGetProjectPerson } from './people/getProjectPerson.js';
  import { getProjectsReportingUserTaskCompletionDefinition as getProjectsReportingUserTaskCompletion, handleGetProjectsReportingUserTaskCompletion } from './reporting/getUserTaskCompletion.js';
  import { getProjectsReportingUtilizationDefinition as getProjectsReportingUtilization, handleGetProjectsReportingUtilization } from './people/getUtilization.js';
  
  // Time-related imports
  import { getTimeDefinition as getTime, handleGetTime } from './time/getTime.js';
  import { getProjectsAllocationsTimeDefinition as getAllocationTime, handleGetProjectsAllocationsTime } from './time/getAllocationTime.js';
  
  // Core
  import { getTimezonesDefinition as getTimezones, handleGetTimezones } from './core/getTimezones.js';
  
  // Define a structure that pairs tool definitions with their handlers
  interface ToolPair {
    definition: any;
    handler: Function;
  }
  
  // Create an array of tool pairs
  const toolPairs: ToolPair[] = [
    { definition: getProjects, handler: handleGetProjects },
    { definition: getCurrentProject, handler: handleGetCurrentProject },
    { definition: createProject, handler: handleCreateProject },
    { definition: getTasks, handler: handleGetTasks },
    { definition: getTasksByProjectId, handler: handleGetTasksByProjectId },
    { definition: getTaskListsByProjectId, handler: handleGetTaskListsByProjectId },
    { definition: getTasksByTaskListId, handler: handleGetTasksByTaskListId },
    { definition: getTaskById, handler: handleGetTaskById },
    { definition: createTask, handler: handleCreateTask },
    { definition: createSubTask, handler: handleCreateSubTask },
    { definition: updateTask, handler: handleUpdateTask },
    { definition: deleteTask, handler: handleDeleteTask },
    { definition: getTasksMetricsComplete, handler: handleGetTasksMetricsComplete },
    { definition: getTasksMetricsLate, handler: handleGetTasksMetricsLate },
    { definition: getTaskSubtasks, handler: handleGetTaskSubtasks },
    { definition: getTaskComments, handler: handleGetTaskComments },
    { definition: createComment, handler: handleCreateComment },
    { definition: getPeople, handler: handleGetPeople },
    { definition: getPersonById, handler: handleGetPersonById },
    { definition: getProjectPeople, handler: handleGetProjectPeople },
    { definition: addPeopleToProject, handler: handleAddPeopleToProject },
    { definition: deletePerson, handler: handleDeletePerson },
    { definition: updatePerson, handler: handleUpdatePerson },
    { definition: createCompany, handler: handleCreateCompany },
    { definition: updateCompany, handler: handleUpdateCompany },

• src/services/companies/updateCompany.ts:1-25 (helper)

  Service layer function that makes the PATCH API call to 'companies/{companyId}.json' with the provided company data.

  import logger from '../../utils/logger.js';
  import { ensureApiClient } from '../core/apiClient.js';
  
  /**
   * Updates an existing company in Teamwork
   * @param companyId The ID of the company to update
   * @param companyData The company data to update
   * @returns The API response
   */
  export const updateCompany = async (companyId: number, companyData: any) => {
    try {
      logger.info(`Updating company with ID ${companyId}`);
      
      const api = ensureApiClient();
      const response = await api.patch(`companies/${companyId}.json`, companyData);
      
      logger.info(`Successfully updated company with ID ${companyId}`);
      return response.data;
    } catch (error: any) {
      logger.error(`Error updating company with ID ${companyId}: ${error.message}`);
      throw new Error(`Failed to update company with ID ${companyId}: ${error.message}`);
    }
  };
  
  export default updateCompany; 

• src/utils/config.ts:256-256 (registration)

  Configuration listing 'updateCompany' under the 'Companies' group for tool permissions.

  'Companies': ['createCompany', 'updateCompany', 'deleteCompany', 'getCompanies', 'getCompanyById']