add a command to edit existing worklogs

src/api/api.ts

@@ -83,6 +83,16 @@ export default {
         })
     },
 
+    async updateWorklog(worklogId: number, request: AddWorklogRequest): Promise<WorklogEntity> {
+        const credentials = await authenticator.getCredentials()
+        const body = { ...request, authorAccountId: credentials.accountId}
+        return execute(async () => {
+            const response = await tempoAxios.put(`/worklogs/${worklogId}`, body)
+            debugLog(response)
+            return response.data
+        })
+    },
+
     async getWorklogs(request: GetWorklogsRequest): Promise<GetWorklogsResponse> {
         const credentials = await authenticator.getCredentials()
         return execute(async () => {

src/commands/edit.ts

@@ -0,0 +1,67 @@
+import {Command, flags} from '@oclif/command'
+import {appName} from '../appName'
+import {trimIndent} from '../trimIndent'
+import tempo from '../tempo'
+import globalFlags from '../globalFlags'
+
+export default class Edit extends Command {
+    static description = '[or e], edit a worklog entry with a given id)'
+
+    static examples = [
+        `${appName} edit 123456 -d "new desc"`,
+        `${appName} e 123456 -i ISSUE_KEY_OR_ALIAS`,
+        `${appName} e 123456 -t 13-15:30 `
+    ]
+
+    static aliases = ['e']
+
+    static flags = {
+        help: flags.help({char: 'h'}),
+        debug: flags.boolean(),
+        description: flags.string({
+            char: 'd',
+            description: 'the new description for the worklog being edited'
+        }),
+        issue: flags.string({
+            char: 'i',
+            description: 'the issue or alias for an issue you want to move the worklog to'
+        }),
+        time: flags.string({
+            char: 't',
+            description: 'the new worklog duration (e.g 15m) or interval (e.g 11:30-14)'
+        }),
+        start: flags.string({
+            char: 's',
+            description: 'start time (HH:mm format), used when the input is a duration'
+        }),
+        'remaining-estimate': flags.string({
+            char: 'r',
+            description: 'remaining estimate'
+        }),
+        when: flags.string({
+            char: 'w',
+            description: 'change the date of the worklog'
+        })
+    }
+
+    static args = [
+        {
+            name: 'worklog_id',
+            description: 'worklog id to edit, like 123456',
+            required: true
+        }
+    ]
+
+    async run() {
+        const {args, flags} = this.parse(Edit)
+        globalFlags.debug = flags.debug
+        await tempo.updateUserWorklog(args.worklog_id, {
+            description: flags.description,
+            issueKeyOrAlias: flags.issue,
+            durationOrInterval: flags.time,
+            startTime: flags.start,
+            remainingEstimate: flags["remaining-estimate"],
+            when: flags.when
+        })
+    }
+}

src/tempo.ts

@@ -1,5 +1,5 @@
 import authenticator from './config/authenticator'
-import worklogs, { AddWorklogInput } from './worklogs/worklogs'
+import worklogs, {AddWorklogInput, UpdateWorklogInput} from './worklogs/worklogs'
 import prompts from './config/prompts'
 import * as worklogsTable from './worklogs/worklogsTable'
 import chalk from 'chalk'
@@ -63,6 +63,14 @@ export default {
         }
     },
 
+    async updateUserWorklog(worklog_id: string, input: UpdateWorklogInput) {
+        return execute(async () => {
+            cli.action.start(`Updating worklog with id ${worklog_id}`)
+            const worklog = await worklogs.updateWorklog(worklog_id, input)
+            cli.action.stop('Done.')
+        })
+    },
+
     async listUserWorklogs(when?: string, verbose = false) {
         execute(async () => {
             cli.action.start('Loading worklogs')

src/worklogs/worklogs.ts

@@ -24,6 +24,15 @@ export type AddWorklogInput = {
     remainingEstimate?: string
 }
 
+export type UpdateWorklogInput = {
+    issueKeyOrAlias?: string
+    durationOrInterval?: string
+    description?: string
+    startTime?: string,
+    remainingEstimate?: string,
+    when?: string
+}
+
 export type Worklog = {
     id: string,
     interval?: Interval,
@@ -44,13 +53,7 @@ export default {
     async addWorklog(input: AddWorklogInput): Promise<Worklog> {
         await checkToken()
         const referenceDate = parseWhenArg(time.now(), input.when)
-        const parseResult = timeParser.parse(input.durationOrInterval, referenceDate)
-        if (parseResult == null) {
-            throw Error(`Error parsing "${input.durationOrInterval}". Try something like 1h10m or 11-12:30. See ${appName} log --help for more examples.`)
-        }
-        if (parseResult.seconds <= 0) {
-            throw Error('Error. Minutes worked must be larger than 0.')
-        }
+        const parseResult = parseInputDate(input.durationOrInterval, referenceDate)
         const issueKey = await aliases.getIssueKey(input.issueKeyOrAlias) ?? input.issueKeyOrAlias
         const worklogEntity = await api.addWorklog({
             issueKey: issueKey,
@@ -95,7 +98,50 @@ export default {
             credentials.accountId
         )
         return { worklogs, date, scheduleDetails }
+    },
+
+    async updateWorklog(worklogIdInput: string, input: UpdateWorklogInput) {
+        const worklogId = parseInt(worklogIdInput)
+        if (!Number.isInteger(worklogId)) {
+            throw Error('Error. Worklog id should be an integer number.')
+        }
+        const currentWorklog = await api.getWorklog(worklogId)
+        const referenceDate = parseWhenArg(time.now(), input.when ? input.when : currentWorklog.startDate);
+        let parseResult = undefined
+        if(input.durationOrInterval) {
+            parseResult = parseInputDate(input.durationOrInterval, referenceDate)
+        }
+
+        const issueKey = input.issueKeyOrAlias ? input.issueKeyOrAlias : currentWorklog.issue.key;
+        const issue = await aliases.getIssueKey(issueKey) ?? issueKey
+        let worklogEntity;
+        const request = {
+            issueKey: issue,
+            timeSpentSeconds: parseResult ? parseResult.seconds : currentWorklog.timeSpentSeconds,
+            startDate: format(referenceDate, DATE_FORMAT),
+            startTime: parseResult ? startTime(parseResult, input.startTime, referenceDate) : currentWorklog.startTime,
+            description: input.description ? input.description : currentWorklog.description,
+            remainingEstimateSeconds: remainingEstimateSeconds(referenceDate, input.remainingEstimate)
+        };
+        if(input.issueKeyOrAlias) {
+            await this.deleteWorklog(worklogIdInput);
+            worklogEntity = await api.addWorklog(request);
+        } else {
+            worklogEntity = await api.updateWorklog(worklogId, request)
+        }
+        return toWorklog(worklogEntity)
+    }
+}
+
+function parseInputDate(durationOrInterval: string, referenceDate: Date) : ParseResult {
+    const parseResult = timeParser.parse(durationOrInterval, referenceDate);
+    if (parseResult == null) {
+        throw Error(`Error parsing "${durationOrInterval}". Try something like 1h10m or 11-12:30. See ${appName} log --help for more examples.`)
+    }
+    if (parseResult.seconds <= 0) {
+        throw Error('Error. Minutes worked must be larger than 0.')
     }
+    return parseResult;
 }
 
 function remainingEstimateSeconds(referenceDate: Date, remainingEstimate?: string): number | undefined {