getTime

Instructions

Implementation Reference

• src/tools/time/getTime.ts:139-154 (handler)

  Handler function for the getTime tool. Calls the getTime service and returns the response as text content, or returns an error response on failure.

  export async function handleGetTime(input: any) {
    try {
      logger.info('Handling getTime tool request');
      const response = await getTimeService(input);
      
      logger.info('Successfully handled getTime request');
      return {
        content: [{
          type: "text",
          text: JSON.stringify(response, null, 2)
        }]
      };
    } catch (error: any) {
      return createErrorResponse(error, 'Getting time entries');
    }
  } 

• src/tools/time/getTime.ts:8-134 (schema)

  Tool definition including name, description, inputSchema with all filter parameters, and annotations.

  export const getTimeDefinition = {
    name: "getTime",
    description: "Get all time entries. Return all logged time entries for all projects. Only the time entries that the logged-in user can access will be returned.",
    inputSchema: {
      type: 'object',
      properties: {
        updatedAfter: {
          type: 'string',
          description: 'filter by updated after date'
        },
        startDate: {
          type: 'string',
          description: 'filter by a starting date'
        },
        reportFormat: {
          type: 'string',
          description: 'define the format of the report'
        },
        projectStatus: {
          type: 'string',
          description: 'filter by project status',
          enum: [
            'active',
            'current',
            'late',
            'upcoming',
            'completed',
            'deleted'
          ]
        },
        orderMode: {
          type: 'string',
          description: 'order mode',
          enum: [
            'asc',
            'desc'
          ]
        },
        orderBy: {
          type: 'string',
          description: 'sort order',
          enum: [
            'company',
            'date',
            'dateupdated',
            'project',
            'task',
            'tasklist',
            'user',
            'description',
            'billed',
            'billable',
            'timespent'
          ]
        },
        invoicedType: {
          type: 'string',
          description: 'filter by invoiced type',
          enum: [
            'all',
            'invoiced',
            'noninvoiced'
          ]
        },
        endDate: {
          type: 'string',
          description: 'filter by an ending date'
        },
        billableType: {
          type: 'string',
          description: 'filter by billable type',
          enum: [
            'all',
            'billable',
            'non-billable'
          ]
        },
        updatedBy: {
          type: 'integer',
          description: 'filter by the user who updated the timelog'
        },
        ticketId: {
          type: 'integer',
          description: 'filter by ticket id'
        },
        tasklistId: {
          type: 'integer',
          description: 'filter by tasklist id'
        },
        taskId: {
          type: 'integer',
          description: 'filter by task id (deprecated, use taskIds)'
        },
        projectId: {
          type: 'integer',
          description: 'filter by project id (deprecated, use projectIds)'
        },
        pageSize: {
          type: 'integer',
          description: 'number of items in a page'
        },
        page: {
          type: 'integer',
          description: 'page number'
        },
        invoiceId: {
          type: 'integer',
          description: 'filter by invoice id'
        },
        budgetId: {
          type: 'integer',
          description: 'filter by budget id'
        },
        allocationId: {
          type: 'integer',
          description: 'filter by allocation id'
        }
      },
      required: []
    },
    annotations: {
      title: "Get Time Entries",
      readOnlyHint: false,
      destructiveHint: false,
      openWorldHint: false
    }
  };

• src/services/time/getTime.ts:73-90 (helper)

  Service/helper that makes the actual API call to Teamwork's v3 API endpoint /time.json with the provided query parameters.

  export const getTime = async (params: GetTimeParams = {}) => {
    try {
      logger.info('Fetching time entries from Teamwork');
      
      const api = getApiClientForVersion('v3');
      
      logger.info('Making API request to get time entries');
      const response = await api.get('/time.json', { params });
      
      logger.info('Successfully retrieved time entries');
      return response.data;
    } catch (error: any) {
      logger.error(`Failed to get time entries: ${error.message}`);
      throw new Error(`Failed to get time entries: ${error.message}`);
    }
  };
  
  export default getTime; 

• src/services/time/getTime.ts:4-66 (helper)

  TypeScript interface defining all optional parameters for the getTime service call.

  export interface GetTimeParams {
    updatedAfter?: string;
    startDate?: string;
    reportFormat?: string;
    projectStatus?: 'active' | 'current' | 'late' | 'upcoming' | 'completed' | 'deleted';
    orderMode?: 'asc' | 'desc';
    orderBy?: 'company' | 'date' | 'dateupdated' | 'project' | 'task' | 'tasklist' | 'user' | 'description' | 'billed' | 'billable' | 'timespent';
    invoicedType?: 'all' | 'invoiced' | 'noninvoiced';
    endDate?: string;
    billableType?: 'all' | 'billable' | 'non-billable';
    updatedBy?: number;
    ticketId?: number;
    tasklistId?: number;
    taskId?: number;
    projectId?: number;
    pageSize?: number;
    page?: number;
    invoiceId?: number;
    budgetId?: number;
    allocationId?: number;
    useFallbackMethod?: boolean;
    unattachedTimelogs?: boolean;
    skipCounts?: boolean;
    showDeleted?: boolean;
    returnCostInfo?: boolean;
    returnBillableInfo?: boolean;
    onlyStarredProjects?: boolean;
    matchAllTaskTags?: boolean;
    matchAllTags?: boolean;
    matchAllProjectTags?: boolean;
    isReportDownload?: boolean;
    includeTotals?: boolean;
    includePermissions?: boolean;
    includeDescendants?: boolean;
    includeArchivedProjects?: boolean;
    taskTagIds?: number[];
    taskStatuses?: string[];
    taskIds?: number[];
    tagIds?: number[];
    selectedColumns?: string[];
    projectsFromCompanyId?: number[];
    projectTagIds?: number[];
    projectStatuses?: string[];
    projectOwnerIds?: number[];
    projectIds?: number[];
    projectHealths?: number[];
    projectCompanyIds?: number[];
    projectCategoryIds?: number[];
    include?: string[];
    ids?: number[];
    'fields[users]'?: string[];
    'fields[timelogs]'?: string[];
    'fields[tasks]'?: string[];
    'fields[tasklists]'?: string[];
    'fields[tags]'?: string[];
    'fields[projects]'?: string[];
    'fields[projectcategories]'?: string[];
    'fields[companies]'?: string[];
    assignedToUserIds?: number[];
    assignedToTeamIds?: number[];
    assignedToCompanyIds?: number[];
    assignedTeamIds?: number[];
  }

• src/tools/index.ts:52-111 (registration)

  Registration of the getTime tool: imports the definition and handler, adds it to the toolPairs array, and maps it by name ('getTime') in toolHandlersMap.

  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 },
    { definition: deleteCompany, handler: handleDeleteCompany },
    { definition: getCompanies, handler: handleGetCompanies },
    { definition: getCompanyById, handler: handleGetCompanyById },
    { definition: getProjectsPeopleMetricsPerformance, handler: handleGetProjectsPeopleMetricsPerformance },
    { definition: getProjectsPeopleUtilization, handler: handleGetProjectsPeopleUtilization },
    { definition: getAllocationTime, handler: handleGetProjectsAllocationsTime },
    { definition: getTime, handler: handleGetTime },
    { definition: getProjectPerson, handler: handleGetProjectPerson },
    { definition: getProjectsReportingUserTaskCompletion, handler: handleGetProjectsReportingUserTaskCompletion },
    { definition: getProjectsReportingUtilization, handler: handleGetProjectsReportingUtilization },
    { definition: getTimezones, handler: handleGetTimezones }
  ];
  
  // Extract just the definitions for the toolDefinitions array
  export const toolDefinitions = toolPairs.map(pair => pair.definition);
  
  // Create a map of tool names to their handler functions
  export const toolHandlersMap: Record<string, Function> = toolPairs.reduce((map, pair) => {
    map[pair.definition.name] = pair.handler;
    return map;
  }, {} as Record<string, Function>);