npm package: @parsable/plugin-author-cli
Description: Parsable CLI plugin for authoring functionality
Author: Shealen Clare @sheac
Latest version: 1.1.2

author-cli
==========

Parsable CLI for authoring functionality

[![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
[![Version](https://img.shields.io/npm/v/author-cli.svg)](https://npmjs.org/package/author-cli)
[![Downloads/week](https://img.shields.io/npm/dw/author-cli.svg)](https://npmjs.org/package/author-cli)
[![License](https://img.shields.io/npm/l/author-cli.svg)](https://github.com/parsable/author-cli/blob/master/package.json)

<!-- toc -->
* [Usage](#usage)
* [Commands](#commands)
<!-- tocstop -->
# Usage
<!-- usage -->
```sh-session
$ npm install -g @parsable/plugin-author-cli
$ parsable-cli COMMAND
running command...
$ parsable-cli (-v|--version|version)
@parsable/plugin-author-cli/1.1.2 linux-x64 node-v22.21.1
$ parsable-cli --help [COMMAND]
USAGE
  $ parsable-cli COMMAND
...
```
<!-- usagestop -->
# Commands
<!-- commands -->
* [`parsable-cli exec-data:delete`](#parsable-cli-exec-datadelete)
* [`parsable-cli help [COMMAND]`](#parsable-cli-help-command)
* [`parsable-cli jobs:create`](#parsable-cli-jobscreate)
* [`parsable-cli jobs:delete`](#parsable-cli-jobsdelete)
* [`parsable-cli template:copy`](#parsable-cli-templatecopy)
* [`parsable-cli template:copy:status`](#parsable-cli-templatecopystatus)

## `parsable-cli exec-data:delete`

Delete execution data corresponding to a specific Input Field on a Job.

```
USAGE
  $ parsable-cli exec-data:delete

OPTIONS
  -A, --all
      When set, deletes all execution data regardless of when it was sent to the server.

  -c, --fields-csv=fields-csv
      The absolute path to a CSV file containing rows of field-id/job-base-step-id pairs.
      The CSV file must not start with a header row (the first line must be the first field locator you wish to delete
      data for).
      Each row should have as its first element the field id, and as its second element the job-base-step id.
      Example:
      field_id,job_base_step_id
      abc123,def456
      ghi789,jkl012

  -f, --field-id=field-id
      The id of the Field to delete execution data from.

  -j, --job-base-step-id=job-base-step-id
      The jobBaseStepId of the Field's parent Step.

  --force
      When set, skips the "Are you sure" prompt.

  --from-time=from-time
      Any execution data sent to the server before this timestamp will not be deleted (format: UNIX, seconds since epoch).

  --until-time=until-time
      Any execution data sent to the server on or after this timestamp will not be deleted (format: UNIX, seconds since
      epoch).

DESCRIPTION
  Fields are uniquely identified by locators, which are combinations of:
   1. the 'id' of the Field itself, plus
   2. the 'jobBaseStepId' of the Field's parent Step

  A single locator can be specified inline, using the arguments --field-id and --job-base-step-id.
  Alternatively, a list of locators can be provided in the form of a CSV file via the --fields-csv argument.
  (More details provided below in the context of the --fields-csv argument.)

  A time range must be set using the flags:
   1. 'from-time'
   2. 'until-time'
   3. both of the preceding, or
   4. 'all'
  If no range is set the delete command will not run.
  If 'all' is combined with 'from-time' or 'until-time' the command will not run.

EXAMPLES
  parsable-cli exec-data:delete --field-id=abc123 --job-base-step-id=def456 --all
  parsable-cli exec-data:delete -f abc123 -j def456 -A
  parsable-cli exec-data:delete --field-id=abc123 --job-base-step-id=def456 --from-time=123456789
  parsable-cli exec-data:delete --field-id=abc123 --job-base-step-id=def456 --until-time=123456789
  parsable-cli exec-data:delete --field-id=abc123 --job-base-step-id=def456 --from-time=123456789 --until-time=123456790
  parsable-cli exec-data:delete --fields-csv=/absolute/path/to/my/file.csv --all
  parsable-cli exec-data:delete -c /absolute/path/to/my/file.csv -A
  parsable-cli exec-data:delete -c /absolute/path/to/my/file.csv -A --force
```

_See code: [src/commands/exec-data/delete.js](https://github.com/parsable/author-cli/blob/v1.1.2/src/commands/exec-data/delete.js)_

## `parsable-cli help [COMMAND]`

display help for parsable-cli

```
USAGE
  $ parsable-cli help [COMMAND]

ARGUMENTS
  COMMAND  command to show help for

OPTIONS
  --all  see all commands in CLI
```

_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v3.2.18/src/commands/help.ts)_

## `parsable-cli jobs:create`

Create jobs.

```
USAGE
  $ parsable-cli jobs:create

OPTIONS
  -x, --extended                   show extra columns
  --columns=columns                only show provided columns (comma-separated)
  --csv                            output is csv format [alias: --output=csv]
  --filter=filter                  filter property by partial string matching, ex: name=foo
  --no-header                      hide table header from output
  --no-truncate                    do not truncate output to fit screen
  --number-of-jobs=number-of-jobs  number of job(s) to be created, will default to 1 if left out
  --output=csv|json|yaml           output in a more machine friendly format
  --sort=sort                      property to sort by (prepend '-' for descending)
  --team-id=team-id                (required) Id of the team who will own the jobs

  --template-ids=template-ids      template id(s) to be assigned for the created jobs and should match to the number of
                                   jobs (comma-separated)

  --title=title                    (required) title of the job(s) and should match to the number of jobs
                                   (comma-separated)

DESCRIPTION
  Send a request to create a job(s) and assigned templates.
  Currently it only supports on-demand job type.

EXAMPLES
  parsable-cli jobs:create --team-id=abc123 --title='Job Sample 1'
  parsable-cli jobs:create --team-id=abc123 --number-of-jobs=2 --title='Job Sample 1,Job Sample 2'
  parsable-cli jobs:create --team-id=abc123 --number-of-jobs=2 --title='Job Sample 1,Job Sample 2' 
  --template-ids=<template_id>,<template_id>
```

_See code: [src/commands/jobs/create.js](https://github.com/parsable/author-cli/blob/v1.1.2/src/commands/jobs/create.js)_

## `parsable-cli jobs:delete`

Delete jobs and issues listed in CSV files of lookup/database ids.

```
USAGE
  $ parsable-cli jobs:delete

OPTIONS
  -i, --issues-csv=issues-csv
      Path to a CSV holding the issue lookup ids to be deleted.
      There should be no header row in the CSV.
      Each row is a single item: the lookup id (integer or 'issue-123' format key) or database id (UUID) of the issue to
      be deleted.
      Maximum file length is 5K rows/issues. Beyond that, the CLI may fail to process.

      Example CSV contents:
      1234
      6c807fd4-6594-11eb-ae93-0242ac130002
      5678
      75196fd4-6594-11eb-ae93-0242ac130002

  -j, --jobs-csv=jobs-csv
      Path to a CSV holding the job lookup ids to be deleted.
      There should be no header row in the CSV.
      Each row is a single item: the lookup id (integer or 'job-123' format key) or database id (UUID) of the job to be
      deleted.
      Maximum file length is 5K rows/jobs. Beyond that, the CLI may fail to process.

      Example CSV contents:
      1234
      6c807fd4-6594-11eb-ae93-0242ac130002
      5678
      75196fd4-6594-11eb-ae93-0242ac130002

  -t, --team-id=team-id
      (required) Id of the team owning the jobs

  --force
      When set, skips the "Are you sure?" prompt

DESCRIPTION
  If a job/issue cannot be deleted because it is referenced (depended upon) by another job/issue, then a list of those
  dependents will be output to the files descendant-issues.csv and descendant-jobs.csv accordingly.
  These lists can be fed back into the command on subsequent attempts, issues first and then jobs.
  After the dependents are deleted, you can attempt to delete the original dependency job/issue that failed initially.

EXAMPLES
  parsable-cli jobs:delete --team-id=abc123 --jobs-csv=path/to/the/file.csv
  parsable-cli jobs:delete --team-id=abc123 --issues-csv=path/to/another/file.csv
  parsable-cli jobs:delete -t abc123 -j path/to/the/file.csv -i path/to/another/file.csv
  parsable-cli jobs:delete -t abc123 -i path/to/the/file.csv --force
```

_See code: [src/commands/jobs/delete.js](https://github.com/parsable/author-cli/blob/v1.1.2/src/commands/jobs/delete.js)_

## `parsable-cli template:copy`

Send request to copy templates.

```
USAGE
  $ parsable-cli template:copy

OPTIONS
  -x, --extended
      show extra columns

  --columns=columns
      only show provided columns (comma-separated)

  --config=config
      Path to config json file.
      Config json file should be in the following format:
      {
      "templateIds": [<string>],
      "referenceSheetSetIds": [<string>],
      "source": {
      "teamId": <string>,
      "email": <string>,
      "password": <string>,
      "apiBase": <string>
      },
      "destination": {
      "teamId": <string>,
      "email": <string>,
      "password": <string>,
      "apiBase": <string>
      },
      "options": {
      "includeApplets": <boolean>,
      "includeMetadata": <boolean>,
      "includeProcedureTypes": <boolean>,
      "includeInputTriggers": <boolean>,
      "includeRefSheets": <boolean>
      }
      "shouldPublishTemplates": <boolean>
      }

  --csv
      output is csv format [alias: --output=csv]

  --dest-api-base=dest-api-base
      hostname of the destination team environment

  --dest-email=dest-email
      email of admin user in the destination team

  --dest-password=dest-password
      password of admin user in the destination team

  --dest-team-id=dest-team-id
      destination team id for template(s) to copy into

  --filter=filter
      filter property by partial string matching, ex: name=foo

  --include-applets
      copy applets over

  --include-input-triggers
      copy input triggers over

  --include-metadata
      copy metadata over

  --include-procedure-types
      copy procedure types over

  --include-refsheets
      copy reference sheets over

  --no-header
      hide table header from output

  --no-truncate
      do not truncate output to fit screen

  --output=csv|json|yaml
      output in a more machine friendly format

  --reference-sheet-set-ids=reference-sheet-set-ids
      reference sheet set id(s) from source team to copy to destination team (comma-separated)

  --should-publish-templates
      copied templates should be published

  --sort=sort
      property to sort by (prepend '-' for descending)

  --src-api-base=src-api-base
      hostname of the source team environment

  --src-email=src-email
      email of admin user in the source team

  --src-password=src-password
      password of admin user in the source team

  --src-team-id=src-team-id
      source team id of template(s) to copy from

  --template-ids=template-ids
      template id(s) from source team to copy to destination team (comma-separated)

DESCRIPTION
  Templates arrive at the destination team in Editing (draft) status.
  We do not support copying archived templates.
  Status report id will be returned unless the request takes over 30 seconds.
  Requests that take over 30 seconds will cause the command to timeout.
  This does not mean the request failed.
  You can still check the statuses by template id: `parsable-cli template:copy:request --template-id <template_id>`
  Please use 'parsable-cli login' to specify which environment (staging vs production) to run this command against.
  Reference sheets are automatically copied over if they are associated with the template. Please make sure to include 
  the reference sheet id in the referenceSheetIds config so that templates with reference sheets are copied over 
  correctly.

  Additional Notes:
  * If you try to copy an object and it has attribute values, then the attribute values only copy over if the 
  destination
   team has custom policies on. Otherwise, for destination teams with custom policies off, we do not copy attribute 
  values
  * Metadata = parameters at the Template level. We do not copy anything Job related (job parameters).
   We copy template metadata values if includeMetadata option is added and if the destination team has the exact
   metadata value matches available.

EXAMPLES
  parsable-cli template:copy
  parsable-cli template:copy --config ./config.json
  parsable-cli template:copy --should-publish-templates
  parsable-cli template:copy --template-ids <template_id>,<template_id>
```

_See code: [src/commands/template/copy.js](https://github.com/parsable/author-cli/blob/v1.1.2/src/commands/template/copy.js)_

## `parsable-cli template:copy:status`

Get the statuses for template copy requests.

```
USAGE
  $ parsable-cli template:copy:status

OPTIONS
  -s, --status-report-id=status-report-id  get statuses for this status report id (id found in output of `parsable-cli
                                           template:copy`)

  -t, --template-id=template-id            get statuses for this template id

  -x, --extended                           show extra columns

  --columns=columns                        only show provided columns (comma-separated)

  --csv                                    output is csv format [alias: --output=csv]

  --filter=filter                          filter property by partial string matching, ex: name=foo

  --no-header                              hide table header from output

  --no-truncate                            do not truncate output to fit screen

  --output=csv|json|yaml                   output in a more machine friendly format

  --sort=sort                              property to sort by (prepend '-' for descending)

DESCRIPTION
  There is one status per template copied.
  Status fields returned include:
  template_id, status (FAILED, SUCCESS, IN_PROGRESS, SCHEDULED), result, start_timestamp, end_timestamp, src_team_id, 
  dest_team_id
  Please use 'parsable-cli login' to specify which environment (staging vs production) to run this command against.

EXAMPLES
  parsable-cli template:copy:status
  parsable-cli template:copy:status --status-report-id <status_report_id>
  parsable-cli template:copy:status -s <status_report_id>
  parsable-cli template:copy:status --template-id <template_id>
  parsable-cli template:copy:status -t <template_id>
  parsable-cli template:copy:status --output json
  parsable-cli template:copy:status --filter status=FAILED
```

_See code: [src/commands/template/copy/status.js](https://github.com/parsable/author-cli/blob/v1.1.2/src/commands/template/copy/status.js)_
<!-- commandsstop -->