API Operations

Summary

Operation Name: Retrieve API Metadata
Relative API Request Path: ~/api/v1/metadata/current
HTTP Verb: GET
Description: Retrieves the current API metadata

Retrieve API Metadata

Description: This API method provides metadata regarding the current API version.

The response code on success will be 200 (OK), and the response body will include the current server UTC date and the current API version.

ReadAPIMetadataDTO {
UtcDate (string, optional): ISO 8601 string ,
APIVersion (string, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Data: 400

Response DTO Property Notes:

• The UTCDate property represents the UTC datetime for the server

Sample Request URL: ~/api/v1/metadata/current

{
  "UtcDate": "2023-10-02T16:37:23.9575928Z",
  "APIVersion": "16.1.1"
}

Summary

Operation Name: Retrieve an Attachment by Attachment ID
Relative API Request Path: ~/api/v1/attachments/{attachmentID}/{includeAttachmentContent}
HTTP Verb: GET
Description: Retrieve a single Attachment by its Attachment ID with the option of specifying whether or not to retrieve the attachment file content.

Operation Name: Retrieve a Collection of Attachments by Issue Number
Relative API Request Path: ~/api/v1/attachments/issueNumber/{issueNumber}/{includeAttachmentContent}
HTTP Verb: GET
Description: Retrieve a collection of Attachments for an associated Issue Number with the option of specifying whether or not to retrieve the attachment file content.

Operation Name: Retrieve a Collection of Attachments by IssueNumber with the Contents of the Attachments Compressed as a ZIP Archive
Relative API Request Path: ~/api/v1/attachments/compressed/issueNumber/{issueNumber}
HTTP Verb: GET
Description: Retrieve a collection of Attachments for an associated Issue Number with the contents of the attachment compressed as a ZIP Archive.

Operation Name: Create Attachment for Issue
Relative API Request Path: ~/api/v1/attachments
HTTP Verb: POST
Description: Create a new Attachment for an Issue.

Retrieve an Attachment by Attachment ID

Description: This API method retrieves an Attachment from the Issuetrak data store for a specified Attachment ID. The “attachmentID” parameter must correspond to an existing Attachment. If there is no such Attachment ID, an error message will be returned with an HTTP response status code of 404.

The “includeAttachmentContent” parameter is an optional parameter that defaults to true. If false, (e.g., /attachments/1/false), the ReadAttachmentDTO FileContent property will be null representing the skipped operation of retrieving the attachment file content.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadAttachmentDTO instance.

ReadAttachmentDTO {
ExtensionData (Array[CustomKeyValuePairDataElement], optional),
Metadata (Array[CustomKeyValuePairDataElement], optional),
AttachmentID (integer, optional),
IssueNumber (integer, optional),
FileName (string, optional),
CreatedBy (string, optional),
CreatedDate (string, optional): ISO 8601 string,
FileSizeInBytes (integer, optional),
FileContent (string, optional): Base64 string
}
CustomKeyValuePairDataElement {
Key (string, optional),
Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Attachment ID: 400 (Bad Request)
• Non-existent Attachment: 404
• Invalid Attachment ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response DTO Property Notes:

• The FileSizeInBytes property value should equal the number of bytes present in the FileContent byte array after decoding from base-64.
• The FileContent property will contain the base-64 encoded contents of the Attachment file.
• The ExtensionData property will contain an echo of the “includeAttachmentContent” parameter setting for the request.
• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/attachments/5420/true

{
  "ExtensionData": [
    {
      "Key": "includeAttachmentContent",
      "Value": true
    }
  ],
  "Metadata": [
    {
      "Key": "APIVersion",
      "Value": "16.1.1"
    },
    {
      "Key": "QueryDate",
      "Value": "2023-09-28T22:32:18.2576819Z"
    }
  ],
  "AttachmentID": 949,
  "IssueNumber": 5420,
  "FileName": "Test_file.txt",
  "CreatedBy": "admin",
  "CreatedDate": "2023-09-28T18:31:44.913",
  "FileSizeInBytes": 4,
  "FileContent": "MTIzNA=="
}

Retrieve a Collection of Attachments by Issue Number

Description: This API method retrieves a collection of Attachments from the Issuetrak data store for the specified Issue Number. The “issueNumber” parameter must correspond to an existing Issue. If there is no such Issue Number, an error message will be returned with an HTTP response status code of 404.

The “includeAttachmentContent” parameter is an optional parameter that defaults to true. If false, (e.g., /attachments/1/false), the ReadAttachmentDTO FileContent property will be null representing the skipped operation of retrieving the attachment file content.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadAttachmentDTO instances.

QueryResultsContainer[ReadAttachmentDTO] {
IsPageIndexZeroBased (boolean, optional),
PageIndex (integer, optional),
CountForPage (integer, optional),
PageSize (integer, optional),
TotalCount (integer, optional),
Collection (Array[ReadAttachmentDTO], optional)
}
ReadAttachmentDTO {
ExtensionData (Array[CustomKeyValuePairDataElement], optional),
Metadata (Array[CustomKeyValuePairDataElement], optional),
AttachmentID (integer, optional),
IssueNumber (integer, optional),
FileName (string, optional),
CreatedBy (string, optional),
CreatedDate (string, optional): ISO 8601 string,
FileSizeInBytes (integer, optional),
FileContent (string, optional): Base64 string
}
CustomKeyValuePairDataElement {
Key (string, optional),
Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Issue Number: 400 (Bad Request)
• Non-existent Issue: 404
• Non-existent Attachment: 404
• Invalid Issue Number 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response DTO Property Notes:

• The IsPageIndexZeroBased property value is always true. This property is included for use in future API versions.
• The PageIndex property value is always 0. This property is included for use in future API versions.
• The CountForPage property value is always the same as TotalCount. This property is included for use in future API versions.
• The PageSize property value is always the maximum value for a signed, 32-bit integer. This property is included for use in future API versions.
• The TotalCount property value is the number of records returned in the collection.
• The Collection property is an array containing the ReadAttachmentDTO objects returned.
• The ExtensionData property will contain an echo of the “includeAttachmentContent” parameter setting for the request.

{
  "IsPageIndexZeroBased": true,
  "PageIndex": 0,
  "CountForPage": 1,
  "PageSize": 2147483647,
  "TotalCount": 1,
  "Collection": [
    {
      "ExtensionData": [
        {
          "Key": "includeAttachmentContent",
          "Value": true
        }
      ],
      "Metadata": [
        {
          "Key": "APIVersion",
          "Value": "16.1.1"
        },
        {
          "Key": "QueryDate",
          "Value": "2023-09-28T22:32:02.5487022Z"
        }
      ],
      "AttachmentID": 949,
      "IssueNumber": 5420,
      "FileName": "Test_file.txt",
      "CreatedBy": "admin",
      "CreatedDate": "2023-09-28T18:31:44.913",
      "FileSizeInBytes": 4,
      "FileContent": "MTIzNA=="
    }
  ]
}

Retrieve a Collection of Attachments by Issue Number with the Contents of the Attachments Compressed as a ZIP Archive

Description:This API method retrieves a collection of Attachment from the Issuetrak data store for the specified Issue Number. The “issueNumber” parameter must correspond to an existing Issue. If there is no such Issue Number, an error message will be returned with an HTTP response status code of 404.

The content of the retrieved attachments are compressed as a ZIP archive.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized “QueryResults” instance with a Collection property containing a set of ReadAttachmentDTO instances. For each of the ReadAttachmentDTO instances, the FileContent property will be null and the ExtensionData property will contain a key / value pair with the key name, “CompressedEntryName”. The value of the “CompressedEntryName” key will represent the name of the ZIP archive entry corresponding to the byte content for the ReadAttachmentDTO instance’s compressed content.

A successful response will include a second root object, “CompressedAttachmentsContent”, representing the Base-64 encoded representation of the ZIP archive of the attachments for the queried Issue.

ReadAttachmentsForIssueNumberCompressedDTO {
ExtensionData (Array[CustomKeyValuePairDataElement], optional),
Metadata (Array[CustomKeyValuePairDataElement], optional),
QueryResults (QueryResultsContainer[ReadAttachmentDTO], optional),
CompressedAttachmentsContent (string, optional): Base64 string
}
CustomKeyValuePairDataElement {
Key (string, optional),
Value (object, optional)
}
QueryResultsContainer[ReadAttachmentDTO] {
IsPageIndexZeroBased (boolean, optional),
PageIndex (integer, optional),
CountForPage (integer, optional),
PageSize (integer, optional),
TotalCount (integer, optional),
Collection (Array[ReadAttachmentDTO], optional)
}
ReadAttachmentDTO {
ExtensionData (Array[CustomKeyValuePairDataElement], optional),
Metadata (Array[CustomKeyValuePairDataElement], optional),
AttachmentID (integer, optional),
IssueNumber (integer, optional),
FileName (string, optional),
CreatedBy (string, optional),
CreatedDate (string, optional): ISO 8601 string,
FileSizeInBytes (integer, optional),
FileContent (string, optional): Base64 string
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Issue Number: 400 (Bad Request)
• Non-existent Issue: 404
• Non-existent Attachment: 404
• Invalid Issue Number 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response DTO Property Notes:

• The IsPageIndexZeroBased property value is always true. This property is included for use in future API versions.
• The PageIndex property value is always 0. This property is included for use in future API versions.
• The CountForPage property value is always the same as TotalCount. This property is included for use in future API versions.
• The PageSize property value is always the maximum value for a signed, 32-bit integer. This property is included for use in future API versions.
• The TotalCount property value is the number of records returned in the collection.
• The Collection property is an array containing the ReadAttachmentDTO objects returned.
• The ExtensionData properties for the ReadAttachmentDTO instances included within the QueryResults Collection will contain a key/value pair with the key name, “CompressedEntryName”, representing the ZIP archive entry name for the attachment. The “CompressedEntryName” is randomly-generated value for every request to allow attachments with the same base name to be compressed.

Sample Request URL: ~/api/v1/attachments/compressed/issueNumber/5420

{
  "ExtensionData": [],
  "Metadata": [
    {
      "Key": "APIVersion",
      "Value": "16.1.1"
    },
    {
      "Key": "QueryDate",
      "Value": "2023-09-28T22:40:35.7942367Z"
    }
  ],
  "QueryResults": {
    "IsPageIndexZeroBased": true,
    "PageIndex": 0,
    "CountForPage": 1,
    "PageSize": 2147483647,
    "TotalCount": 1,
    "Collection": [
      {
        "ExtensionData": [
          {
            "Key": "CompressedEntryName",
            "Value": "2ughmbhe.nnh"
          }
        ],
        "Metadata": [],
        "AttachmentID": 949,
        "IssueNumber": 5420,
        "FileName": "Test_file.txt",
        "CreatedBy": "admin",
        "CreatedDate": "2023-09-28T18:31:44.913",
        "FileSizeInBytes": 4,
        "FileContent": null
      }
    ]
  },
  "CompressedAttachmentsContent": "UEsDBBQAAAAIABGVPFej4OObBgAAAAQAAAAMAAAAMnVnaG1iaGUubm5oMzQyNgEAUEsBAhQAFAAAAAgAEZU8V6Pg45sGAAAABAAAAAwAAAAAAAAAAAAAAAAAAAAAADJ1Z2htYmhlLm5uaFBLBQYAAAAAAQABADoAAAAwAAAAAAA="
}

Create Attachment for Issue

Description: This method creates a new Attachment associated with a specific Issue (identified by IssueNumber) within the Issuetrak data store. The CreateAttachmentDTO object conveys the properties and file content of the new Attachment. Because Attachments are associated with Issues, the IssueNumber property of the DTO must correspond to an existing Issue. If there is no such Issue Number, an error message will be returned with a 400 HTTP status code.

A successful response will include an HTTP status code of 201 (Created), and the response body will represent the 32-bit integer value representing the ID of the newly-created Attachment.

CreateAttachmentDTO {
IssueNumber (integer, optional),
FileName (string, optional),
CreatedBy (string, optional),
CreatedDate (string, optional): ISO 8601 string,
FileSizeInBytes (integer, optional),
FileContent (string, optional): Base64 string
}

Request HTTP Verb: POST

Response Status Codes:

• Success: 201 (Created)
• Invalid Data: 400
• Non-existent Issue: 400

Response DTO Property Notes:

• The FileName property value must comply with the character limitations imposed on standard Windows file names.
• The CreatedBy property value must reference an existing, active User within the Issuetrak application.
• The FileSizeInBytes property value must match the number of bytes present in FileContent after decoding from base-64.
• The FileContent property value must contain the base-64-encoded contents of the Attachment file.

Sample Request URL: ~/api/v1/attachments/

{
  "IssueNumber": 5420,
  "FileName": "testfile2.txt",
  "CreatedBy": "admin",
  "CreatedDate": "2023-09-28T18:41:44.913",
  "FileSizeInBytes": 4,
  "FileContent": "MTIzNA=="
}

Sample Response HTTP Status Code: 201

Sample Response Body: 140367 (represents the newly-created Attachment ID)

Summary

Operation Name: Retrieve a Cause by Cause ID
Relative API Request Path: ~/api/v1/causes/{causeID}
HTTP Verb: GET
Description: Retrieve a single Cause by Cause ID.

Operation Name: Retrieve all Causes
Relative API Request Path: ~/api/v1/causes
HTTP Verb: GET
Description: Retrieve a collection of currently defined Causes.

Retrieve a Cause by Cause ID

Description: This API method retrieves a Cause from the Issuetrak data store for a specified Cause ID. The “causeID” parameter must correspond to an existing Cause. If there is no such Cause ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a Cause using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the CauseName returned via the API method represents the CauseName as stored within the Issuetrak database. Thus, when retrieving a Cause created through the Issuetrak web interface where HTML encoding of the CauseName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadCauseDTO instance.

ReadCauseDTO {
ExtensionData (Array[CustomKeyValuePairDataElement], optional),
Metadata (Array[CustomKeyValuePairDataElement], optional),
CauseID (integer, optional),
CauseName (string, optional),
DisplayOrder (number, optional)
}
CustomKeyValuePairDataElement {
Key (string, optional),
Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Cause ID: 400 (Bad Request)
• Non-existent Cause: 404
• Invalid Cause ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response Properties:

• The ExtensionData property is not used in version 1 of the API.
• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/causes/6

{
  "ExtensionData": [],
  "Metadata": [
    {
      "Key": "APIVersion",
      "Value": "16.1.1"
    },
    {
      "Key": "QueryDate",
      "Value": "2023-10-04T14:08:50.9197234Z"
    }
  ],
  "CauseID": 6,
  "CauseName": "Hardware Fault",
  "DisplayOrder": 0
}

Retrieve all Causes

Description: This API method retrieves a collection of all currently-defined Causes from the Issuetrak data store.

When retrieving a Cause using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the CauseName returned via the API method represents the CauseName as stored within the Issuetrak database. Thus, when retrieving a Cause created through the Issuetrak web interface where HTML encoding of the CauseName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadCauseDTO instance.

QueryResultsContainer[ReadCauseDTO] {
IsPageIndexZeroBased (boolean, optional),
PageIndex (integer, optional),
CountForPage (integer, optional),
PageSize (integer, optional),
TotalCount (integer, optional),
Collection (Array[ReadCauseDTO], optional)
}
ReadCauseDTO {
ExtensionData (Array[CustomKeyValuePairDataElement], optional),
Metadata (Array[CustomKeyValuePairDataElement], optional),
CauseID (integer, optional),
CauseName (string, optional),
DisplayOrder (number, optional)
}
CustomKeyValuePairDataElement {
Key (string, optional),
Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent Cause: 404

Response Properties:

• The IsPageIndexZeroBased property value is always true. This property is included for use in future API versions.
• The PageIndex property value is always 0. This property is included for use in future API versions.
• The CountForPage property value is always the same as TotalCount. This property is included for use in future API versions.
• The PageSize property value is always the maximum value for a signed, 32-bit integer. This property is included for use in future API versions.
• The TotalCount property value is the number of records returned in the collection.
• The Collection property is an array containing the ReadCauseDTO objects returned.

Sample Request URL: ~/api/v1/causes/

{
  "IsPageIndexZeroBased": true,
  "PageIndex": 0,
  "CountForPage": 3,
  "PageSize": 2147483647,
  "TotalCount": 3,
  "Collection": [
    {
      "ExtensionData": [],
      "Metadata": [
        {
          "Key": "APIVersion",
          "Value": "16.1.1"
        },
        {
          "Key": "QueryDate",
          "Value": "2023-10-04T14:11:38.8857994Z"
        }
      ],
      "CauseID": 5,
      "CauseName": "User Error",
      "DisplayOrder": 0
    },
    {
      "ExtensionData": [],
      "Metadata": [
        {
          "Key": "APIVersion",
          "Value": "16.1.1"
        },
        {
          "Key": "QueryDate",
          "Value": "2023-10-04T14:11:38.8857994Z"
        }
      ],
      "CauseID": 6,
      "CauseName": "Hardware Fault",
      "DisplayOrder": 0
    },
    {
      "ExtensionData": [],
      "Metadata": [
        {
          "Key": "APIVersion",
          "Value": "16.1.1"
        },
        {
          "Key": "QueryDate",
          "Value": "2023-10-04T14:11:38.8857994Z"
        }
      ],
      "CauseID": 7,
      "CauseName": "Server Outage",
      "DisplayOrder": 0
    }
  ]
}

Summary

Operation Name: Retrieve a Class by Class ID
Relative API Request Path: ~/api/v1/classes/{classID}
HTTP Verb: GET
Description: Retrieve a single Class by Class ID.

Operation Name: Retrieve all Classes
Relative API Request Path: ~/api/v1/classes
HTTP Verb: GET
Description: Retrieve a collection of currently defined Classes.

Retrieve a Class by Class ID

Description: This API method retrieves a Class from the Issuetrak data store for a specified Class ID. The “classID” parameter must correspond to an existing Class. If there is no such Class ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a Class using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the Class Name returned via the API method represents the Class Name as stored within the Issuetrak database. Thus, when retrieving a Class created through the Issuetrak web interface where HTML encoding of the ClassName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadClassDTO instance.

ReadClassDTO
{
 ExtensionData (array[KeyValuePair[String,Object]]),
 Metadata (array[KeyValuePair[String,Object]]),
 ClassID: (integer),
 ClassName: (string),
 DisplayOrder: (number),
 IsActive: (boolean)
}
CustomKeyValuePairDataElement 
{
 Key (string),
 Value (object)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Class ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Class: 404
• Invalid Class ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response Properties:

• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/classes/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “12.5”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2014-12-09T20:19:23.9695584Z”
  }
 ],
 “ClassID”: 11,
 “ClassName”: “General”,
 “DisplayOrder”: 1,
 “IsActive”: false
}

Retrieve all Classes

Description: This API method retrieves a collection of all currently-defined Classes from the Issuetrak data store.

When retrieving a Class using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the ClassName returned via the API method represents the ClassName as stored within the Issuetrak database. Thus, when retrieving a Class created through the Issuetrak web interface where HTML encoding of the ClassName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadClassDTO instance.

QueryResultsContainer[ReadClassDTO]
{
 IsPageIndexZeroBased (boolean),
 PageIndex (integer),
 CountForPage (integer),
 PageSize (integer),
 TotalCount (integer),
 Collection (Array[ReadClassDTO])
}
ReadClassDTO
{
 ExtensionData (Array[CustomKeyValuePairDataElement]),
 Metadata (Array[CustomKeyValuePairDataElement]),
 ClassID (integer),
 ClassName (string),
 DisplayOrder (number),
 IsActive (boolean)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (object)
} 

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent Class: 404

Sample Request URL: ~/api/v1/classes/

{
  “IsPageIndexZeroBased”: true,
  “PageIndex”: 0,
  “CountForPage”: 1,
  “PageSize”: 2147483647,
  “TotalCount”: 1,
  “Collection”: [
   {
    "ExtensionData": [],
    "Metadata": [
     {
      "Key": "APIVersion",
      "Value": "12.5"
     },
     {
      "Key": "QueryDate",
      "Value": "2020-12-16T15:05:29.4366741Z"
     }
   ],
   “ClassID”: 1,
   “ClassName”: “General”,
   “DisplayOrder”: 1,
   “IsActive”: false
  }
 ]
}

Summary

Operation Name: Retrieve a Department by Department ID
Relative API Request Path: ~/api/v1/departments/{departmentID}
HTTP Verb: GET
Description: Retrieve a single Department by Department ID.

Operation Name: Retrieve all Departments
Relative API Request Path: ~/api /v1/departments
HTTP Verb: GET
Description: Retrieve a collection of currently defined Departments.

Retrieve a Department by Department ID

Description: This API method retrieves a Department from the Issuetrak data store for a specified Department ID. The “departmentID” parameter must correspond to an existing Department. If there is no such Department ID, an error message will be returned with an HTTP response status code of 404.

When retrieving an Department using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the DepartmentName returned via the API method represents the DepartmentName as stored within the Issuetrak database. Thus, when retrieving a Department created through the Issuetrak web interface where HTML encoding of the DepartmentName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadDepartmentDTO instance.

ReadDepartmentDTO
{
 ExtensionData (Array[CustomKeyValuePairDataElement]),
 Metadata (Array[CustomKeyValuePairDataElement]),
 DepartmentID (integer),
 DepartmentName (string),
 IsActive (boolean),
 IsInternal (boolean)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (object)
} 

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Department ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Department: 404
• Invalid Department ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/departments/11

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “12.5”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2014-12-09T20:19:23.9695584Z”
  }
 ],
 “DepartmentID”: 11,
 “DepartmentName”: “Accounting”,
 “IsActive”: true,
 “IsInternal”: true
}

Retrieve all Departments

Description: This API method retrieves a collection of all currently-defined Departments from the Issuetrak data store.

When retrieving an Department using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the DepartmentName returned via the API method represents the DepartmentName as stored within the Issuetrak database. Thus, when retrieving a Department created through the Issuetrak web interface where HTML encoding of the DepartmentName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadDepartmentDTO instance.

QueryResultsContainer[ReadDepartmentDTO]
{
 IsPageIndexZeroBased (boolean),
 PageIndex (integer),
 CountForPage (integer),
 PageSize (integer),
 TotalCount (integer),
 Collection (Array[ReadDepartmentDTO])
}
ReadDepartmentDTO
{
 ExtensionData (Array[CustomKeyValuePairDataElement]),
 Metadata (Array[CustomKeyValuePairDataElement]),
 DepartmentID (integer),
 DepartmentName (string),
 IsActive (boolean),
 IsInternal (boolean)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (object)
} 

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent Department: 404

Sample Request URL: ~/api/v1/departments/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   "ExtensionData": [],
   "Metadata": [
     {
      "Key": "APIVersion",
      "Value": "12.5"
     },
     {
      "Key": "QueryDate",
      "Value": "2020-12-16T15:28:40.4767848Z"
     }
   ],
   “DepartmentID”: 2,
   “DepartmentName”: "Management",
   “IsActive”: true,
   “IsInternal”: true
  }
 ]
}

Summary

Operation Name: Retrieve an Issue by Issue Number
Relative API Request Path: ~/api/v1/issues/{includeNotes}/{issueNumber}
HTTP Verb: GET
Description: Retrieve a single Issue by Issue Number.

Operation Name: Retrieve a Collection of Issues for a List of Issue Numbers
Relative API Request Path: ~/api /v1/issues/{includeNotes}/list
HTTP Verb: GET
Description: Retrieve a collection of issues for a delimited list of issue numbers.

Operation Name: Create an Issue
Relative API Request Path: ~/api/v1/issues
HTTP Verb: POST
Description: Create a new Issue.

Operation Name: Update an Issue
Relative API Request Path: ~/api/v1/issues
HTTP Verb: PUT
Description: Update an existing Issue.

Operation Name: Search Issues
Relative API Request Path: ~/api/v1/issues/search
HTTP Verb: POST
Description: Search issues for specified search filters, ordering instructions, and paging boundaries.

Retrieve an Issue by Issue Number

Description: This API method retrieves an Issue from the Issuetrak data store for a specified Issue Number value. The “IssueNumber” parameter must correspond to an existing Issue. If there is no such Issue Number, an error message will be returned with an HTTP response status code of 400.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadIssueDTO instance.

The ReadIssueDTO response instance will contain a collection of ReadNoteDTO instances if the {includeNotes} parameter was specified as true; otherwise, the “Notes” array will be null.

The ReadIssueDTO response instance will contain a collection of ReadIssueUserDefinedFieldDTO representing the user-defined fields defined for the Issue if any user-defined fields are defined.

When retrieving an Issue using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the Subject, Description, and NoteText returned via the API method represents the text as stored within the Issuetrak database. Thus, when retrieving an Issue created through the Issuetrak web interface where HTML encoding of the Subject, Description, and NoteText are performed, the API consumer may desire to perform additional client-side decoding.

ReadIssueDTO {
     IssueNumber (integer, optional),
     IssueSolution (string, optional),
     Status (string, optional),
     ClosedBy (string, optional),
     ClosedDate (string, optional): ISO 8601 string ,
     SubmittedDate (string, optional): ISO 8601 string ,
     CauseID (integer, optional),
     SeverityID (integer, optional),
     Slaid (integer, optional),
     ResponseTime (string, optional): ISO 8601 string ,
     SLAComplianceStatus (string, optional),
     IsFirstCallResolution (boolean, optional),
     Notes (Array[ReadNoteDTO], optional),
     UserDefinedFields (Array[ReadIssueUserDefinedFieldDTO], optional),
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     Subject (string, optional),
     Description (string, optional),
     IsDescriptionRichText (boolean, optional),
     IssueTypeID (integer, optional),
     IssueSubTypeID (integer, optional),
     IssueSubType2ID (integer, optional),
     IssueSubType3ID (integer, optional),
     IssueSubType4ID (integer, optional),
     PriorityID (integer, optional),
     AssetNumber (integer, optional),
     LocationID (string, optional),
     SubmittedBy (string, optional),
     AssignedTo (string, optional),
     TargetDate (string, optional): ISO 8601 string ,
     RequiredByDate (string, optional): ISO 8601 string ,
     NextActionTo (string, optional),
     SubStatusID (integer, optional),
     ProjectID (integer, optional),
     OrganizationID (integer, optional),
     ShouldNeverSendEmailForIssue (boolean, optional),
     ClassID (integer, optional),
     DepartmentID (integer, optional),
     SpecialFunction1 (string, optional),
     SpecialFunction2 (string, optional),
     SpecialFunction3 (string, optional),
     SpecialFunction4 (string, optional),
     SpecialFunction5 (string, optional)
}
ReadNoteDTO {
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     NoteID (integer, optional),
     IssueNumber (integer, optional),
     CreatedDate (string, optional): ISO 8601 string ,
     CreatedBy (string, optional),
     ModifiedBy (string, optional),
     ModifiedDate (string, optional): ISO 8601 string ,
     NoteText (string, optional),
     IsPrivate (boolean, optional),
     IsRichText (boolean, optional)
}
ReadIssueUserDefinedFieldDTO {
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     IssueNumber (integer, optional),
     DisplayName (string, optional),
     UserDefinedFieldID (integer, optional),
     Value (string, optional)
}
CustomKeyValuePairDataElement {
     Key (string, optional),
     Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Issue Number: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Issue: 404
• Invalid Issue Number: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response Properties:

• The Notes property represents the collection of ReadNoteDTO instances for the Issue.
• The UserDefinedFields property represents the collection of ReadIssueUserDefinedFieldDTO instances for the Issue.
• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/issues/false/101502

{
 “IssueNumber”: 101502,
 “IssueSolution”: null,
 “Status”: “Open”,
 “ClosedBy”: “APIUser”,
 “ClosedDate”: “2015-02-12T11:23:42.193”,
 “SubmittedDate”: “2014-07-30T13:38:10.12”,
 “CauseID”: null,
 “SeverityID”: 3,
 “SLAID”: 1,
 “ResponseTime”: null,
 “SLAComplianceStatus”: “InCompliance”,
 “Notes”: [],
 “UserDefinedFields”: [
  {
   “ExtensionData”: [],
   “Metadata”: [],
   “IssueNumber”: 101502,
   “DisplayName”: “Large Text 1”,
   “UserDefinedFieldID”: 4,
   “Value”: “Large Text 1 User-defined Field Property Updated on: 02/12/2015 11:23:42”
  },
  {
   “ExtensionData”: [],
   “Metadata”: [],
   “IssueNumber”: 101502,
   “DisplayName”: “Large Text 2”,
   “UserDefinedFieldID”: 5,
   “Value”: “Large Text 2 User-defined Field Property Updated on: 02/12/2015 11:23:42”
  }
 ],
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “12.5”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2015-02-12T18:54:10.1544752Z”
  }
 ],
 “Subject”: “This Issue's Subject (DB: IssueDescription) was updated on 02/12/2015 11:23:42.ZAOUPDNCAJRDRYKOLTRNPWIMMFASXCJWOIKYYBZWCSAWUGUITWMAZBYDSCHJCUEYAVPIOMPJTUKXWLSFKSZBPIWMJGGWTPUHNBWYRLTGGC”,
 “Description”: “This description was created on 2/12/2015 12:32:30 PM. Random text follows: GTQAPNDPVYYODEJGSOUAABSTFQZDTMUMIQEDEMZUDICNKQXQDAMWPBLFAWVY”,
 “IsDescriptionRichText”: false,
 “IssueTypeID”: 5,
 “IssueSubTypeID”: null,
 “IssueSubType2ID”: null,
 “IssueSubType3ID”: null,
 “IssueSubType4ID”: null,
 “PriorityID”: 1,
 “AssetNumber”: null,
 “LocationID”: "",
 “SubmittedBy”: “Issuetrak”,
 “AssignedTo”: “Issuetrak”,
 “TargetDate”: null,
 “RequiredByDate”: null,
 “NextActionTo”: null,
 “SubStatusID”: 12,
 “ProjectID”: null,
 “OrganizationID”: 1,
 “ShouldNeverSendEmailForIssue”: false,
 “ClassID”: 1,
 “DepartmentID”: 1,
 “SpecialFunction1”: null,
 “SpecialFunction2”: null,
 “SpecialFunction3”: null,
 “SpecialFunction4”: null,
 “SpecialFunction5”: null
}

Retrieve a Collection of Issues for a List of Issue Numbers

Description: This method retrieves a collection of Issues from the Issuetrak data store for a list of specified Issue Numbers. The list is passed to the method via a custom query string parameter of comma-delimited Issue Number values.

The Issue Number values must correspond to existing Issues. If there is no such IssueNumber, an error message will be returned with an HTTP response status code of 400.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadIssueDTO instances.

Each ReadIssueDTO response instance will contain a collection of ReadNoteDTO instances if the {includeNotes} parameter was specified as true; otherwise, the “Notes” array will be null.

Each ReadIssueDTO response instance will contain a collection of ReadIssueUserDefinedFieldDTO representing the user-defined fields defined for the Issue if any user-defined fields are defined.

When retrieving an Issue using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the Subject, Description, and NoteText returned via the API method represents the text as stored within the Issuetrak database. Thus, when retrieving an Issue created through the Issuetrak web interface where HTML encoding of the Subject, Description, and NoteText are performed, the API consumer may desire to perform additional client-side decoding.

Sample Request URL: ~/api/v1/issues/false/101502

QueryResultsContainer[ReadIssueDTO] {
     IsPageIndexZeroBased (boolean, optional),
     PageIndex (integer, optional),
     CountForPage (integer, optional),
     PageSize (integer, optional),
     TotalCount (integer, optional),
     Collection (Array[ReadIssueDTO], optional)
}
ReadIssueDTO {
     IssueNumber (integer, optional),
     IssueSolution (string, optional),
     Status (string, optional),
     ClosedBy (string, optional),
     ClosedDate (string, optional): ISO 8601 string ,
     SubmittedDate (string, optional): ISO 8601 string ,
     CauseID (integer, optional),
     SeverityID (integer, optional),
     Slaid (integer, optional),
     ResponseTime (string, optional): ISO 8601 string ,
     SLAComplianceStatus (string, optional),
     IsFirstCallResolution (boolean, optional),
     Notes (Array[ReadNoteDTO], optional),
     UserDefinedFields (Array[ReadIssueUserDefinedFieldDTO], optional),
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     Subject (string, optional),
     Description (string, optional),
     IsDescriptionRichText (boolean, optional),
     IssueTypeID (integer, optional),
     IssueSubTypeID (integer, optional),
     IssueSubType2ID (integer, optional),
     IssueSubType3ID (integer, optional),
     IssueSubType4ID (integer, optional),
     PriorityID (integer, optional),
     AssetNumber (integer, optional),
     LocationID (string, optional),
     SubmittedBy (string, optional),
     AssignedTo (string, optional),
     TargetDate (string, optional): ISO 8601 string ,
     RequiredByDate (string, optional): ISO 8601 string ,
     NextActionTo (string, optional),
     SubStatusID (integer, optional),
     ProjectID (integer, optional),
     OrganizationID (integer, optional),
     ShouldNeverSendEmailForIssue (boolean, optional),
     ClassID (integer, optional),
     DepartmentID (integer, optional),
     SpecialFunction1 (string, optional),
     SpecialFunction2 (string, optional),
     SpecialFunction3 (string, optional),
     SpecialFunction4 (string, optional),
     SpecialFunction5 (string, optional)
}
ReadNoteDTO {
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     NoteID (integer, optional),
     IssueNumber (integer, optional),
     CreatedDate (string, optional): ISO 8601 string ,
     CreatedBy (string, optional),
     ModifiedBy (string, optional),
     ModifiedDate (string, optional): ISO 8601 string ,
     NoteText (string, optional),
     IsPrivate (boolean, optional),
     IsRichText (boolean, optional)
}
ReadIssueUserDefinedFieldDTO {
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     IssueNumber (integer, optional),
     DisplayName (string, optional),
     UserDefinedFieldID (integer, optional),
     Value (string, optional)
}
CustomKeyValuePairDataElement {
    Key (string, optional),
    Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent Issue: 400
• Invalid Issue Number List: 422 (Unprocessable Entity, e.g., negative or non-numeric values are supplied)

Sample Request URL: ~api/v1/issues/true/list?issueNumbers=5504%2C5548

{
  "IsPageIndexZeroBased": true,
  "PageIndex": 0,
  "CountForPage": 2,
  "PageSize": 2147483647,
  "TotalCount": 2,
  "Collection": [
    {
      "IssueNumber": 5504,
      "IssueSolution": "",
      "Status": "Open",
      "ClosedBy": null,
      "ClosedDate": null,
      "SubmittedDate": "2023-11-20T15:03:57.127",
      "CauseID": null,
      "SeverityID": null,
      "Slaid": null,
      "ResponseTime": null,
      "SLAComplianceStatus": "NotAnSLAIssue",
      "IsFirstCallResolution": null,
      "Notes": [
        {
          "ExtensionData": [],
          "Metadata": [],
          "NoteID": 27400,
          "IssueNumber": 5504,
          "CreatedDate": "2024-01-22T13:19:27.327",
          "CreatedBy": "admin",
          "ModifiedBy": null,
          "ModifiedDate": null,
          "NoteText": "Test note for 5504",
          "IsPrivate": false,
          "IsRichText": true
        }
      ],
      "UserDefinedFields": [],
      "ExtensionData": [],
      "Metadata": [
        {
          "Key": "APIVersion",
          "Value": "16.3.1"
        },
        {
          "Key": "QueryDate",
          "Value": "2024-01-22T18:19:44.3796472Z"
        }
      ],
      "Subject": "test 2",
      "Description": "Test Description",
      "IsDescriptionRichText": true,
      "IssueTypeID": 5,
      "IssueSubTypeID": 22,
      "IssueSubType2ID": 0,
      "IssueSubType3ID": 0,
      "IssueSubType4ID": 0,
      "PriorityID": 9,
      "AssetNumber": 0,
      "LocationID": "",
      "SubmittedBy": "admin",
      "AssignedTo": "admin",
      "TargetDate": null,
      "RequiredByDate": null,
      "NextActionTo": null,
      "SubStatusID": 12,
      "ProjectID": 0,
      "OrganizationID": 1,
      "ShouldNeverSendEmailForIssue": false,
      "ClassID": 12,
      "DepartmentID": 0,
      "SpecialFunction1": "",
      "SpecialFunction2": "",
      "SpecialFunction3": "",
      "SpecialFunction4": "",
      "SpecialFunction5": ""
    },
    {
      "IssueNumber": 5548,
      "IssueSolution": "",
      "Status": "Open",
      "ClosedBy": null,
      "ClosedDate": null,
      "SubmittedDate": "2024-01-19T00:08:19.397",
      "CauseID": null,
      "SeverityID": null,
      "Slaid": null,
      "ResponseTime": null,
      "SLAComplianceStatus": "NotAnSLAIssue",
      "IsFirstCallResolution": null,
      "Notes": [
        {
          "ExtensionData": [],
          "Metadata": [],
          "NoteID": 27399,
          "IssueNumber": 5548,
          "CreatedDate": "2024-01-22T13:18:21.317",
          "CreatedBy": "admin",
          "ModifiedBy": null,
          "ModifiedDate": null,
          "NoteText": "Test Note",
          "IsPrivate": false,
          "IsRichText": true
        }
      ],
      "UserDefinedFields": [
        {
          "ExtensionData": [
            {
              "Key": "68",
              "Value": "Item1"
            }
          ],
          "Metadata": [],
          "IssueNumber": 5548,
          "DisplayName": "Test multi-select<>?$&^%&",
          "UserDefinedFieldID": 42,
          "Value": "68"
        },
        {
          "ExtensionData": [
            {
              "Key": "IsListValue",
              "Value": "true"
            },
            {
              "Key": "LabelForListValue",
              "Value": "abcd"
            }
          ],
          "Metadata": [],
          "IssueNumber": 5548,
          "DisplayName": "Claim Status",
          "UserDefinedFieldID": 39,
          "Value": "49"
        },
        {
          "ExtensionData": [
            {
              "Key": "12",
              "Value": "test45"
            }
          ],
          "Metadata": [],
          "IssueNumber": 5548,
          "DisplayName": "Equipment Type",
          "UserDefinedFieldID": 11,
          "Value": "12"
        }
      ],
      "ExtensionData": [],
      "Metadata": [
        {
          "Key": "APIVersion",
          "Value": "16.3.1"
        },
        {
          "Key": "QueryDate",
          "Value": "2024-01-22T18:19:44.3796472Z"
        }
      ],
      "Subject": "IT - Offsite backup storage media rotation",
      "Description": "Take existing onsite backup media to offsite storage location and bring back oldest backup media ",
      "IsDescriptionRichText": true,
      "IssueTypeID": 9,
      "IssueSubTypeID": 0,
      "IssueSubType2ID": 0,
      "IssueSubType3ID": 0,
      "IssueSubType4ID": 0,
      "PriorityID": 3,
      "AssetNumber": 0,
      "LocationID": "NOR",
      "SubmittedBy": "admin",
      "AssignedTo": "Interal_IT_Group",
      "TargetDate": null,
      "RequiredByDate": "2024-01-31T00:00:00",
      "NextActionTo": null,
      "SubStatusID": 12,
      "ProjectID": 0,
      "OrganizationID": 1,
      "ShouldNeverSendEmailForIssue": false,
      "ClassID": 0,
      "DepartmentID": 8,
      "SpecialFunction1": "",
      "SpecialFunction2": "",
      "SpecialFunction3": "",
      "SpecialFunction4": "",
      "SpecialFunction5": ""
    }
  ]
}

Create an Issue

Description: This API method creates a new Issue within the Issuetrak data store. The CreateIssueDTO object conveys the properties of the new Issue along with any Note instances or User-defined Field instances to be associated with the new Issue. If invalid data are supplied, an error message will be returned with a 400 HTTP status code.

Depending on the activation of Issuetrak application features, the only acceptable value for a property associated with an application feature that is not activated is null. For example, for the “Use Issue Classes” feature, if the feature is disabled, the “ClassID” property for the CreateIssueDTO instance must be set to null.

For example, if a non-null value is provided for the “ClassID” property and the “Use Issue Classes” feature is not activated, an error of the following form will be returned:

The specified value for the ‘ClassID' property is invalid because the 'Issue Classes’ feature is not activated.

Please note that the value of the ProjectID property (if specified) must represent the Int32 ID value for an existing project. The existing projects may be retrieved using the “Get All Projects” method of the Projects API controller. Within the Issuetrak UI, the “ProjectID” property refers to the user-assigned project text identifier, not the Int32 value.

The response code on success will be 201 (Created), and the response body will represent the 32-bit integer value representing the ID of the newly-created Issue.

Sample Request URL: ~api/v1/issues/true/list?issueNumbers=5504%2C5548

CreateIssueDTO {
     ShouldSuppressEmailForCreateOperation (boolean, optional),
     Notes (Array[CreateNoteWithIssueDTO], optional),
     UserDefinedFields (Array[CreateIssueUserDefinedFieldDTO], optional),
     SubmittedDate (string, optional): ISO 8601 string ,
     EnteredBy (string, optional),
     SeverityID (integer, optional),
     Subject (string, optional),
     Description (string, optional),
     IsDescriptionRichText (boolean, optional),
     IssueTypeID (integer, optional),
     IssueSubTypeID (integer, optional),
     IssueSubType2ID (integer, optional),
     IssueSubType3ID (integer, optional),
     IssueSubType4ID (integer, optional),
     PriorityID (integer, optional),
     AssetNumber (integer, optional),
     LocationID (string, optional),
     SubmittedBy (string, optional),
     AssignedTo (string, optional),
     TargetDate (string, optional): ISO 8601 string ,
     RequiredByDate (string, optional): ISO 8601 string ,
     NextActionTo (string, optional),
     SubStatusID (integer, optional),
     ProjectID (integer, optional),
     OrganizationID (integer, optional),
     ShouldNeverSendEmailForIssue (boolean, optional),
     ClassID (integer, optional),
     DepartmentID (integer, optional),
     SpecialFunction1 (string, optional),
     SpecialFunction2 (string, optional),
     SpecialFunction3 (string, optional),
     SpecialFunction4 (string, optional),
     SpecialFunction5 (string, optional)
}
CreateNoteWithIssueDTO {
     CreatedDate (string, optional): ISO 8601 string ,
     CreatedBy (string, optional),
     NoteText (string, optional),
     IsPrivate (boolean, optional),
     IsRichText (boolean, optional)
}
CreateIssueUserDefinedFieldDTO {
     UserDefinedFieldID (integer, optional),
     Value (string, optional)
}

Request HTTP Verb: POST

Response Status Codes:

• Success: 201
• Invalid Data: 400

Request Properties:

• The ShouldSuppressEmailForCreateOperation property value determines whether or not e-mail notifications will be sent by Issuetrak during the creation of this Issue. If ‘false', e-mail notifications will be sent normally. If 'true’, e-mail notifications will not be sent.
• The CreatedBy property value must reference an existing, active User within the Issuetrak application.

Sample Request URL: ~/api/v1/issues/

{
 “ShouldSuppressEmailForCreateOperation”: true,
 “Notes”: [],
 “UserDefinedFields”: [
  {
   “UserDefinedFieldID”: 4,
   “Value”: “Large Text 1 User-defined Field Property Created on: 10/09/2014 04:27:02. Random text follows: FOHTYEGRVNTSEHYRQTTAXDETWXDDITCCRNITGTUGEJC”
  },
  {
   “UserDefinedFieldID”: 5,
   “Value”: “Large Text 2 User-defined Field Property Created on: 10/09/2014 04:27:02. Random text follows: FOHTYEGRVNTSEHYRQTTAXDETWXDDITCCRNITGTUGEJC”
  }
 ],
 “SubmittedDate”: “2014-10-09T16:27:02.1445287Z”,
 “EnteredBy”: “Admin”,
 “SeverityID”: 1,
 “Subject”: “This subject was created on 10/09/2014 04:27:02. Random text follows:  SDYBUFPYRPRXGSURGMFWNJZXILVOSWKTKQTCXLKZSK”,
 “Description”: “This description was created on 10/09/2014 04:27:02. Random text follows: FOHTYEGRVNTSEHYRQTTAXDETWXDDITCCRNITGTUGEJCSUZRKALDFVFKCKOX”,
 “IsDescriptionRichText”: false,
 “IssueTypeID”: 0,
 “IssueSubTypeID”: 0,
 “IssueSubType2ID”: 0,
 “IssueSubType3ID”: 0,
 “IssueSubType4ID”: 0,
 “PriorityID”: 1,
 “AssetNumber”: 0,
 “LocationID”: "",
 “SubmittedBy”: “Admin”,
 “AssignedTo”: "",
 “TargetDate”: null,
 “RequiredByDate”: null,
 “NextActionTo”: "",
 “SubStatusID”: 0,
 “ProjectID”: 0,
 “OrganizationID”: 1,
 “ShouldNeverSendEmailForIssue”: true,
 “ClassID”: 1,
 “DepartmentID”: 1,
 “SpecialFunction1”: null,
 “SpecialFunction2”: null,
 “SpecialFunction3”: null,
 “SpecialFunction4”: null,
 “SpecialFunction5”: null
}

Sample Response HTTP Status Code: 201

Sample Response Body: 104416

Update an Issue

Description: This API method updates an existing Issue within the Issuetrak data store. The UpdateIssueDTO object conveys the properties of the Issue along with any User-defined Field instances to be associated with the new Issue. If invalid data are supplied, an error message will be returned with a 400 HTTP status code.

Depending on the activation of Issuetrak application features, the only acceptable value for a property associated with an application feature that is not activated is null. For example, for the “Use Issue Classes” feature, if the feature is disabled, the “ClassID” property for the UpdateIssueDTO instance must be set to null.

For example, if a non-null value is provided for the “ClassID” property and the “Use Issue Classes” feature is not activated, an error of the following form will be returned:

The specified value for the ‘ClassID' property is invalid because the 'Issue Classes’ feature is not activated.

Please note that the value of the ProjectID property (if specified) must represent the Int32 ID value for an existing project. The existing projects may be retrieved using the “Get All Projects” method of the Projects API controller. Within the Issuetrak UI, the “ProjectID” property refers to the user-assigned project text identifier, not the Int32 value.

The response code on success will be 200 (OK), and the response body will represent the 32-bit integer value representing the Issue Number of the updated Issue.

Sample Request URL: ~/api/v1/issues/

UpdateIssueDTO {
     IssueNumber (integer, optional),
     IssueSolution (string, optional),
     Status (string, optional),
     ClosedBy (string, optional),
     ClosedDate (string, optional): ISO 8601 string ,
     CauseID (integer, optional),
     ShouldSuppressEmailForUpdateOperation (boolean, optional),
     UserDefinedFields (Array[UpdateIssueUserDefinedFieldDTO], optional),
     SeverityID (integer, optional),
     ResponseTime (string, optional): ISO 8601 string ,
     IsFirstCallResolution (boolean, optional),
     Subject (string, optional),
     Description (string, optional),
     IsDescriptionRichText (boolean, optional),
     IssueTypeID (integer, optional),
     IssueSubTypeID (integer, optional),
     IssueSubType2ID (integer, optional),
     IssueSubType3ID (integer, optional),
     IssueSubType4ID (integer, optional),
     PriorityID (integer, optional),
     AssetNumber (integer, optional),
     LocationID (string, optional),
     SubmittedBy (string, optional),
     AssignedTo (string, optional),
     TargetDate (string, optional): ISO 8601 string ,
     RequiredByDate (string, optional): ISO 8601 string ,
     NextActionTo (string, optional),
     SubStatusID (integer, optional),
     ProjectID (integer, optional),
     OrganizationID (integer, optional),
     ShouldNeverSendEmailForIssue (boolean, optional),
     ClassID (integer, optional),
     DepartmentID (integer, optional),
     SpecialFunction1 (string, optional),
     SpecialFunction2 (string, optional),
     SpecialFunction3 (string, optional),
     SpecialFunction4 (string, optional),
     SpecialFunction5 (string, optional)
}
UpdateIssueUserDefinedFieldDTO {
     IssueNumber (integer, optional),
     UserDefinedFieldID (integer, optional),
     Value (string, optional)
}

Request HTTP Verb: POST

Response Status Codes:

• Success: 200
• Invalid Data: 400

Request Properties:

• The ShouldSuppressEmailForUpdateOperation property value determines whether or not e-mail notifications will be sent by Issuetrak during the update of this Issue. If ‘false', e-mail notifications will be sent normally. If 'true’, e-mail notifications will not be sent.

Sample Request URL: ~/api/v1/issues/

{
 “ID”: 79048,
 “IssueNumber”: 79048,
 “IssueSolution”: "",
 “Status”: “Open”,
 “ClosedBy”: "",
 “ClosedDate”: null,
 “CauseID”: null,
 “ShouldSuppressEmailForUpdateOperation”: false,
 “UserDefinedFields”: [
  {
   “IssueNumber”: 79048,
   “UserDefinedFieldID”: 4,
   “Value”: “Large Text 1 User-defined Field Property Updated on: 10/09/2014 04:30:00”
  },
  {
   “IssueNumber”: 79048,
   “UserDefinedFieldID”: 5,
   “Value”: “Large Text 2 User-defined Field Property Updated on: 10/09/2014 04:30:00”
  }
 ],
 “SeverityID”: 1,
 “ResponseTIme”: “2014-10-9T10:55:00”,
 “IsFirstCallResolution”: false,
 “Subject”: “This Issue's Subject (DB: IssueDescription) was updated on 10/09/2014 04:30:00.UPVBSPTMYCPPPLJPPDFQVMOPUEFFBTETYJIBXKOPQFPJSPULDNAYKZOIAGGNJOKEXWQGCHRFOQAPWFXFK”,
 “Description”: “This Issue's Description (first note) was updated on 10/09/2014 04:30:00.UPVBSPTMYCPPPLJPPDFQVMOPUEFFBTETYJIBXKOPQFPJSPULDNAYKZOIAGGNJOKEXWQGCHRFQAPWFXFKUBN”,
 “IsDescriptionRichText”: false,
 “IssueTypeID”: null,
 “IssueSubTypeID”: null,
 “IssueSubType2ID”: null,
 “IssueSubType3ID”: null,
 “IssueSubType4ID”: null,
 “Priority”: “High”,
 “AssetNumber”: null,
 “LocationID”: "",
 “SubmittedBy”: “Admin”,
 “AssignedTo”: "",
 “TargetDate”: null,
 “RequiredByDate”: null,
 “NextActionTo”: "",
 “SubStatusID”: 14,
 “ProjectID”: null,
 “OrganizationID”: 1,
 “ShouldNeverSendEmailForIssue”: null,
 “ClassID”: 1,
 “DepartmentID”: 1,
 “SpecialFunction1”: null,
 “SpecialFunction2”: null,
 “SpecialFunction3”: null,
 “SpecialFunction4”: null,
 “SpecialFunction5”: null
}

Sample Response HTTP Status Code: 200

Sample Response Body: 79048 (represents the Issue Number for the Issue updated)

Search Issues

Description: This method retrieves a collection of Issues from the Issuetrak data store for specified query set definitions. The query set definitions can contain one or more query expressions arranged into query sets with each query set related to the other query sets via an “AND” or “OR” logical operator.

To search on User Defined Fields, specify the FieldName property of the query expression using the format “UDI.ID” where ID is the primary key of the UDFields table record for the User Defined Field you want to search on. For example, if you want to search Issues on a User Defined Field with a primary key in the UDFields table of 5 you would use FieldName = “UDI.5”.

Additionally, to change the output result set ordering, one or more query order definitions may be specified with each query order definition consisting of a property name over which to apply the sorting and the sorting direction: ASC or DESC.

Paging of the results is specified by including a zero-based page index and the desired page size.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadIssueDTO instances.

Each ReadIssueDTO response instance will contain a collection of ReadNoteDTO instances if the {CanIncludeNotes} property was specified as true; otherwise, the “Notes” array will be null.

Each ReadIssueDTO response instance will contain a collection of ReadIssueUserDefinedFieldDTO representing the user-defined fields defined for the Issue if any user-defined fields are defined.

When retrieving an Issue using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the Subject, Description, and NoteText returned via the API method represents the text as stored within the Issuetrak database. Thus, when retrieving an Issue created through the Issuetrak web interface where HTML encoding of the Subject, Description, and NoteText are performed, the API consumer may desire to perform additional client-side decoding.

SearchIssueDTO {
     CanIncludeNotes (boolean, optional),
     QuerySetDefinitions (Array[SearchQuerySetDTO], optional),
     QueryOrderingDefinitions (Array[SearchQueryOrderingDTO], optional),
     PageIndex (integer, optional),
     PageSize (integer, optional)
}
SearchQuerySetDTO {
     QuerySetIndex (integer, optional),
     QuerySetOperator (integer, optional) = ['0', '1', '2'],
     QuerySetExpressions (Array[SearchQueryExpressionDTO], optional)
}
SearchQueryOrderingDTO {
     QueryOrderingDirection (integer, optional) = ['0', '1'],
     FieldName (string, optional)
}
SearchQueryExpressionDTO {
     QueryExpressionOperator (integer, optional) = ['0', '1', '2'],
     QueryExpressionOperation (integer, optional) = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26'],
     FieldName (string, optional),
     FieldFilterValue1 (string, optional),
     FieldFilterValue2 (string, optional)
}

Request HTTP Verb: POST

Response Status Codes:

• Success: 200
• Serialization Issue: 400

Response Properties: None

Sample Request URL: ~/api/v1/issues/search

{
 “QuerySetDefinitions”: [
  {
   “QuerySetIndex”: 0,
   “QuerySetOperator”: “AND”,
   “QuerySetExpressions”: [
    {
     “QueryExpressionOperator”: “AND”,
     “QueryExpressionOperation”: “Equal”,
     “FieldName”: “IssueNumber”,
     “FieldFilterValue1”: “122”,
     “FieldFilterValue2”: ""
    }
   ]
  }
 ],
 “QueryOrderingDefinitions”: [
  {
   “QueryOrderingDirection”: “DESC”,
   “FieldName”: “IssueNumber”
  }
 ],
 “PageIndex”: 0,
 “PageSize”: 10,
 “CanIncludeNotes”: false
}

{
 “QuerySetDefinitions”: [
  {
   “QuerySetIndex”: 0,
   “QuerySetOperator”: “AND”,
   “QuerySetExpressions”: [
    {
     “QueryExpressionOperator”: “AND”,
     “QueryExpressionOperation”: “Between”,
     “FieldName”: “UDI.6”,
     “FieldFilterValue1”: “2013-01-01T00:00:00”,
     “FieldFilterValue2”: “2013-12-31T00:00:00”
    }
   ]
  }
 ],
 “QueryOrderingDefinitions”: [
  {
   “QueryOrderingDirection”: “DESC”,
   “FieldName”: “IssueNumber”
  }
 ],
 “PageIndex”: 0,
 “PageSize”: 10,
 “CanIncludeNotes”: false
}

Sample Response HTTP Status Code: 200

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 10,
 “TotalCount”: 1,
 “Collection”: [
  {
   “IssueNumber”: 122,
   “IssueSolution”: "",
   “Status”: “open”,
   “ClosedBy”: “esmith”,
   “ClosedDate”: “2011-06-27T12:09:16”,
   “SubmittedDate”: “2011-06-23T09:15:00”,
   “CauseID”: null, 
   “Notes”: [],
   “UserDefinedFields”: [
    {
     “ExtensionData”: [],
     “Metadata”: [],
     “IssueNumber”: 122,
     “DisplayName”: “Payment Date”,
     “UserDefinedFieldID”: 6,
     “Value”: “2014-07-31T11:00:00”
    },
    {
     “ExtensionData”: [],
     “Metadata”: [],
     “IssueNumber”: 122,
     “DisplayName”: “Amount”,
     “UserDefinedFieldID”: 7,
     “Value”: 24.99
    }
   ],
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “12.5”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2014-12-05T14:02:55.4400115Z”
    }
   ],
   “Subject”: “Issue Subject”,
   “Description”: “Issue Description”,
   “IsDescriptionRichText”: false,
   “IssueTypeID”: 5,
   “IssueSubTypeID”: 0,
   “IssueSubType2ID”: 0,
   “IssueSubType3ID”: 0,
   “IssueSubType4ID”: 0,
   “Priority”: “Medium”,
   “AssetNumber”: null,
   “LocationID”: "",
   “SubmittedBy”: “admin”,
   “AssignedTo”: "",
   “TargetDate”: null,
   “RequiredByDate”: null,
   “NextActionTo”: null,
   “SubStatusID”: 13,
   “ProjectID”: 0,
   “OrganizationID”: 1,
   “ShouldNeverSendEmailForIssue”: null,
   “ClassID”: 0,
   “DepartmentID”: 0,
   “SpecialFunction1”: "",
   “SpecialFunction2”: "",
   “SpecialFunction3”: "",
   “SpecialFunction4”: "",
   “SpecialFunction5”: ""
  }
 ]
}

Summary

Operation Name: Retrieve an IssueType by IssueType ID
Relative API Request Path: ~/api/v1/issuetypes/{issueTypeID}
HTTP Verb: GET
Description: Retrieve a single IssueType by IssueType ID.

Operation Name: Retrieve all IssueTypes
Relative API Request Path: ~/api/v1/issuetypes
HTTP Verb: GET
Description: Retrieve a collection of currently defined IssueTypes.

Retrieve an IssueType by IssueType ID

Description: This API method retrieves an IssueType from the Issuetrak data store for a specified IssueType ID. The “issueTypeID” parameter must correspond to an existing IssueType. If there is no such IssueType ID, an error message will be returned with an HTTP response status code of 404.

When retrieving an IssueType using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueTypeName returned via the API method represents the IssueTypeName as stored within the Issuetrak database. Thus, when retrieving an IssueType created through the Issuetrak web interface where HTML encoding of the IssueTypeName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadIssueTypeDTO instance.

ReadIssueTypeDTO
{
 ExtensionData (Array[CustomKeyValuePairDataElement]),
 Metadata (Array[CustomKeyValuePairDataElement]),
 IssueTypeID (integer),
 IssueTypeName (string),
 DisplayOrder (number),
 CreatedBy (string),
 CreatedDate (ISO 8601 string),
 ModifiedBy (string),
 ModifiedDate (ISO 8601 string),
 IsActive (boolean),
 TrakTip (string),
 IsTrakTipAdvancedOnly (boolean),
 CustomScreenID (integer)
}
CustomKeyValuePairDataElement 
{
 Key (string),
 Value (object)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid IssueType ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent IssueType: 404
• Invalid IssueType ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/issuetypes/11

{
  “ExtensionData”: [],
  “Metadata”: [
  {
    “Key”: “APIVersion”,
    “Value”: “12.5”
  },
  {
    “Key”: “QueryDate”,
    “Value”: “2020-12-09T20:19:23.9695584Z”
  }
 ],
  “IssueTypeID”: 11,
  “IssueTypeName”: “Duplicate Ticket”,
  “DisplayOrder”: 3,
  “CreatedBy”: “admin”,
  “CreatedDate”: “2017-11-16T08:26:46.44”,
  “ModifiedBy”: null,
  “ModifiedDate”: null,
  “IsActive”: true
  “TrakTip”: “”,
  “IsTrakTipAdvancedOnly”: false,
  “CustomScreenID”: 7
}

Retrieve all IssueTypes

Description: This API method retrieves a collection of all currently-defined IssueTypes from the Issuetrak data store.

When retrieving an IssueType using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueTypeName returned via the API method represents the IssueTypeName as stored within the Issuetrak database. Thus, when retrieving an IssueType created through the Issuetrak web interface where HTML encoding of the IssueTypeName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadIssueTypeDTO instance.

QueryResultsContainer[ReadIssueTypeDTO]
{
 IsPageIndexZeroBased (boolean),
 PageIndex (integer),
 CountForPage (integer),
 PageSize (integer),
 TotalCount (integer),
 Collection (array[ReadIssueSubType3DTO])
}
ReadIssueTypeDTO
{
 ExtensionData(array[KeyValuePair[String,Object]]),
 Metadata (array[KeyValuePair[String,Object]]),
 IssueTypeID (integer),
 IssueTypeName (string),
 DisplayOrder (number),
 CreatedBy (string),
 CreatedDate (ISO 8601 string),
 ModifiedBy (string),
 ModifiedDate (ISO 8601 string),
 IsActive (boolean),
 TrakTip (string),
 IsTrakTipAdvancedOnly (boolean),
 CustomScreenID (integer)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (object)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent IssueType: 404

Sample Request URL: ~/api/v1/issuetypes

{
  “IsPageIndexZeroBased”: true,
  “PageIndex”: 0,
  “CountForPage”: 1,
  “PageSize”: 2147483647,
  “TotalCount”: 1,
  “Collection”: [
   {
     “ExtensionData”: [],
     “Metadata”: [
      {
        “Key”: “APIVersion”,
        “Value”: “12.5”
      }
      {
        “Key”: “QueryDate”,
        “Value”: “2020-12-10T18:34:37.8439079Z”
      }
   “IssueTypeID”: 5,
   “IssueTypeName”: "Facilities",
   “DisplayOrder”: 1,
   “CreatedBy”: “admin”,
   “CreatedDate”: “2017-11-16T08:26:46.44”,
   “ModifiedBy”: null,
   “ModifiedDate”: null,
   “IsActive”: true
   “TrakTip”: “”,
   “IsTrakTipAdvancedOnly”: false,
   “CustomScreenID”: 2
  }
 ]
}

Summary

Operation Name: Retrieve an IssueSubType by IssueSubType ID
Relative API Request Path: ~/api/v1/issuesubtypes/{issueSubTypeID}
HTTP Verb: GET
Description: Retrieve a single IssueSubType by IssueSubType ID.

Operation Name: Retrieve all IssueSubTypes
Relative API Request Path: ~/api/v1/issuesubtypes
HTTP Verb: GET
Description: Retrieve a collection of currently defined IssueSubTypes.

Retrieve an IssueSubType by IssueSubType ID

Description: This API method retrieves an IssueSubType from the Issuetrak data store for a specified IssueSubType ID. The “issueSubTypeID” parameter must correspond to an existing IssueSubType. If there is no such IssueSubType ID, an error message will be returned with an HTTP response status code of 404.

When retrieving an IssueSubType using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueSubTypeName returned via the API method represents the IssueSubTypeName as stored within the Issuetrak database. Thus, when retrieving an IssueSubType created through the Issuetrak web interface where HTML encoding of the IssueSubTypeName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadIssueSubTypeDTO instance.

ReadIssueSubTypeDTO {
     IssueSubTypeID (integer, optional),
     IssueSubTypeName (string, optional),
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     ParentID (integer, optional),
     DisplayOrder (number, optional),
     CreatedBy (string, optional),
     CreatedDate (string, optional): ISO 8601 string,
     ModifiedBy (string, optional),
     ModifiedDate (string, optional): ISO 8601 string,
     TrakTip (string, optional),
     IsTrakTipAdvancedOnly (boolean, optional),
     IsActive (boolean, optional)
}
CustomKeyValuePairDataElement {
     Key (string, optional),
     Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid IssueSubType ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent IssueSubType: 404
• Invalid IssueSubType ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response Properties:

• The ExtensionData property is not used in version 1 of the API.
• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/issuesubtypes/22

{
  "IssueSubTypeID": 22,
  "IssueSubTypeName": "Facilities",
  "ExtensionData": [],
  "Metadata": [
    {
      "Key": "APIVersion",
      "Value": "16.4.1"
    },
    {
      "Key": "QueryDate",
      "Value": "2024-03-04T18:08:06.825751Z"
    }
  ],
  "ParentID": 5,
  "DisplayOrder": 0,
  "CreatedBy": "admin",
  "CreatedDate": "2019-06-19T14:11:53.823",
  "ModifiedBy": "admin",
  "ModifiedDate": "2023-12-08T18:52:13.557",
  "TrakTip": "",
  "IsTrakTipAdvancedOnly": false,
  "IsActive": true
}

Retrieve all IssueSubTypes

Description: This API method retrieves a collection of all currently-defined IssueSubTypes from the Issuetrak data store.

When retrieving an IssueSubType using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueSubTypeName returned via the API method represents the IssueSubTypeName as stored within the Issuetrak database. Thus, when retrieving an IssueSubType created through the Issuetrak web interface where HTML encoding of the IssueSubTypeName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadIssueSubTypeDTO instance.

QueryResultsContainer[ReadIssueSubTypeDTO] {
     IsPageIndexZeroBased (boolean, optional),
     PageIndex (integer, optional),
     CountForPage (integer, optional),
     PageSize (integer, optional),
     TotalCount (integer, optional),
     Collection (Array[ReadIssueSubTypeDTO], optional)
}
ReadIssueSubTypeDTO {
     IssueSubTypeID (integer, optional),
     IssueSubTypeName (string, optional),
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     ParentID (integer, optional),
     DisplayOrder (number, optional),
     CreatedBy (string, optional),
     CreatedDate (string, optional): ISO 8601 string,
     ModifiedBy (string, optional),
     ModifiedDate (string, optional): ISO 8601 string,
     TrakTip (string, optional),
     IsTrakTipAdvancedOnly (boolean, optional),
     IsActive (boolean, optional)
}
CustomKeyValuePairDataElement {
     Key (string, optional),
     Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent IssueSubType: 404

Sample Request URL: ~/api/v1/issuesubtypes/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “IssueSubTypeID”: 1,
   “IssueSubTypeName”: “Hardware”,
   “ExtensionData”: [],
   “Metadata”: [
    {
      “Key”: “APIVersion”
      “Value": “12.5”
    },
    {
      “Key”: “QueryDate”,
      “Value": “2020-12-08T21:48:57.6823349Z”
    }
   ],
   “ParentID”: 10
   “DisplayOrder”: 0
   “CreatedBy”: “admin”
   “CreatedDate”: “2018-04-25T19:59:11.56”
   “ModifiedBy”: “admin”
   “ModifiedDate”: “2018-04-25T19:59:11.56”
   “TrakTip”: “”
   “IsTrakTipAdvancedOnly”: false,
   “IsActive”: true
  }
 ]
}

Summary

Operation Name: Retrieve an IssueSubType2 by IssueSubType2 ID
Relative API Request Path: ~/api/v1/issuesubtypes2/{issueSubType2ID}
HTTP Verb: GET
Description: Retrieve a single IssueSubType2 by IssueSubType2 ID.

Operation Name: Retrieve all IssueSubTypes2
Relative API Request Path: ~/api/v1/issuesubtypes2
HTTP Verb: GET
Description: Retrieve a collection of currently defined IssueSubTypes2.

Retrieve an IssueSubType2 by IssueSubType2 ID

Description: This API method retrieves an IssueSubType2 from the Issuetrak data store for a specified IssueSubType2 ID. The “issueSubType2ID” parameter must correspond to an existing IssueSubType2. If there is no such IssueSubType2 ID, an error message will be returned with an HTTP response status code of 404.

When retrieving an IssueSubType2 using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueSubType2Name returned via the API method represents the IssueSubType2Name as stored within the Issuetrak database. Thus, when retrieving an IssueSubType2 created through the Issuetrak web interface where HTML encoding of the IssueSubType2Name is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadIssueSubType2DTO instance.

ReadIssueSubType2DTO {
     IssueSubType2ID (integer),
     IssueSubType2Name (string),
     ExtensionData (Array[CustomKeyValuePairDataElement]),
     Metadata (Array[CustomKeyValuePairDataElement]),
     ParentID (integer),
     DisplayOrder (number),
     CreatedBy (string),
     CreatedDate (ISO 8601 string),
     ModifiedBy (string),
     ModifiedDate (ISO 8601 string),
     TrakTip (string),
     IsTrakTipAdvancedOnly (boolean),
     IsActive (boolean)
}
CustomKeyValuePairDataElement {
     Key (string),
     Value (object)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid IssueSubType2 ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent IssueSubType2: 404
• Invalid IssueSubType2 ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response Properties:

• The ExtensionData property is not used in version 1 of the API.
• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/issuesubtypes2/11

{
 “IssueSubType2ID”: 11,
 “IssueSubType2Name”: “Duplicate Ticket”, 
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “12.5”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2020-12-16T19:20:17.4659304Z
  }
 ],
 “ParentID”: 42,
 “DisplayOrder”: 1,
 “CreatedBy”: “admin”
 “CreatedDate”: “2017-11-16T08:25:21.783”
 “ModifiedBy”: “admin”
 “ModifiedDate”: “2017-11-16T08:35:07.21”
 “TrakTip”: “”
 “IsTrakTipAdvancedOnly”: false,
 “IsActive”: true
}

Retrieve all IssueSubTypes2

Description: This API method retrieves a collection of all currently-defined IssueSubTypes2 from the Issuetrak data store.

When retrieving an IssueSubType2 using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueSubType2Name returned via the API method represents the IssueSubType2Name as stored within the Issuetrak database. Thus, when retrieving an IssueSubType2 created through the Issuetrak web interface where HTML encoding of the IssueSubType2Name is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadIssueSubType2DTO instance.

QueryResultsContainer[ReadIssueSubType2DTO] {
     IsPageIndexZeroBased (boolean, optional),
     PageIndex (integer, optional),
     CountForPage (integer, optional),
     PageSize (integer, optional),
     TotalCount (integer, optional),
     Collection (Array[ReadIssueSubType2DTO], optional)
}
ReadIssueSubType2DTO {
     IssueSubType2ID (integer, optional),
     IssueSubType2Name (string, optional),
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     ParentID (integer, optional),
     DisplayOrder (number, optional),
     CreatedBy (string, optional),
     CreatedDate (string, optional): ISO 8601 string,
     ModifiedBy (string, optional),
     ModifiedDate (string, optional): ISO 8601 string,
     TrakTip (string, optional),
     IsTrakTipAdvancedOnly (boolean, optional),
     IsActive (boolean, optional)
}
CustomKeyValuePairDataElement {
     Key (string, optional),
     Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent IssueSubType2: 404

Sample Request URL: ~/api/v1/issuesubtypes2/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “IssueSubType2ID”: 5,
   “IssueSubType2Name”: "Usage",
   “ExtensionData”: [],
   “Metadata”: [
   {
    “Key”: “APIVersion”,
    “Value”: “12.5”
   },
   {
    “Key”: “QueryDate”,
    “Value”: “2020-12-16T19:19:58.2738929Z”
   }
  ],
   “ParentID”: 30,
   “DisplayOrder”: 1,
   “CreatedBy”: “admin”,
   “CreatedDate”: “2017-12-01T11:14:15.423”,
   “ModifiedBy”: null,
   “ModifiedDate”: null,
   “TrakTip”: “”,
   “IsTrakTipAdvancedOnly”: false,
   “IsActive”: true,
  }
 ]
}

Summary

Operation Name: Retrieve an IssueSubType3 by IssueSubType3 ID
Relative API Request Path: ~/api/v1/issuesubtypes3/{issueSubType3ID}
HTTP Verb: GET
Description: Retrieve a single IssueSubType3 by IssueSubType3 ID.

Operation Name: Retrieve all IssueSubTypes3
Relative API Request Path: ~/api/v1/issuesubtypes3
HTTP Verb: GET
Description: Retrieve a collection of currently defined IssueSubTypes3.

Retrieve an IssueSubType3 by IssueSubType3 ID

Description: This API method retrieves an IssueSubType3 from the Issuetrak data store for a specified IssueSubType3 ID. The “issueSubType3ID” parameter must correspond to an existing IssueSubType3. If there is no such IssueSubType3 ID, an error message will be returned with an HTTP response status code of 404.

When retrieving an IssueSubType3 using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueSubType3Name returned via the API method represents the IssueSubType3Name as stored within the Issuetrak database. Thus, when retrieving an IssueSubType3 created through the Issuetrak web interface where HTML encoding of the IssueSubType3Name is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadIssueSubType3DTO instance.

ReadIssueSubType3DTO {
     IssueSubType3ID (integer, optional),
     IssueSubType3Name (string, optional),
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     ParentID (integer, optional),
     DisplayOrder (number, optional),
     CreatedBy (string, optional),
     CreatedDate (string, optional): ISO 8601 string,
     ModifiedBy (string, optional),
     ModifiedDate (string, optional): ISO 8601 string,
     TrakTip (string, optional),
     IsTrakTipAdvancedOnly (boolean, optional),
     IsActive (boolean, optional)
}
CustomKeyValuePairDataElement {
     Key (string, optional),
     Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid IssueSubType3 ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent IssueSubType3: 404
• Invalid IssueSubType3 ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response Properties:

• The ExtensionData property is not used in version 1 of the API.
• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/issuesubtypes3/11

{
  “IssueSubType3ID”: 11,
  “IssueSubType3Name”: “Duplicate Ticket”,
  “ExtensionData”: [],
  “Metadata”: [
  {
    “Key”: “APIVersion”,
    “Value”: “12.5”
  },
  {
    “Key”: “QueryDate”,
    “Value”: “2014-12-09T20:19:23.9695584Z”
  }
 ],
  “ParentID”: 3,
  “DisplayOrder”: 0,
  “CreatedBy”: “admin”
  “CreatedDate”: “2017-11-16T08:26:46.44”,
  “ModifiedBy”: null,
  “ModifiedDate”: null,
  “TrakTip”: “”,
  “IsTrakTipAdvancedOnly”: false,
  “IsActive”: true
}

Retrieve all IssueSubTypes3

Description: This API method retrieves a collection of all currently-defined IssueSubTypes3 from the Issuetrak data store.

When retrieving an IssueSubType3 using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueSubType3Name returned via the API method represents the IssueSubType3Name as stored within the Issuetrak database. Thus, when retrieving an IssueSubType3 created through the Issuetrak web interface where HTML encoding of the IssueSubType3Name is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadIssueSubType3DTO instance.

QueryResultsContainer[ReadIssueSubType3DTO] {
     IsPageIndexZeroBased (boolean, optional),
     PageIndex (integer, optional),
     CountForPage (integer, optional),
     PageSize (integer, optional),
     TotalCount (integer, optional),
     Collection (Array[ReadIssueSubType3DTO], optional)
}
ReadIssueSubType3DTO {
     IssueSubType3ID (integer, optional),
     IssueSubType3Name (string, optional),
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     ParentID (integer, optional),
     DisplayOrder (number, optional),
     CreatedBy (string, optional),
     CreatedDate (string, optional): ISO 8601 string,
     ModifiedBy (string, optional),
     ModifiedDate (string, optional): ISO 8601 string,
     TrakTip (string, optional),
     IsTrakTipAdvancedOnly (boolean, optional),
     IsActive (boolean, optional)
}
CustomKeyValuePairDataElement {
     Key (string, optional),
     Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent IssueSubType3: 404

Sample Request URL: ~/api/v1/issuesubtypes3/

{
  “IsPageIndexZeroBased”: true,
  “PageIndex”: 0,
  “CountForPage”: 1,
  “PageSize”: 2147483647,
  “TotalCount”: 1,
  “Collection”: [
  {
    “IssueSubType3ID”: 0,
    “IssueSubType3Name”: "",
    “ExtensionData”: [],
    “Metadata”: [
   {
     “Key”: “APIVersion”,
     “Value”: “12.5”
   }
   {
     “Key”: “QueryDate”,
     “Value”: “2020-12-10T18:34:37.8439079Z”
   }
  ],
   “ParentID”: 3,
   “DisplayOrder”: 1,
   “CreatedBy”: “admin”,
   “CreatedDate”: “2017-11-16T08:26:46.44”,
   “ModifiedBy”: null,
   “ModifiedDate”: null,
   “TrakTip”: “”,
   “IsTrakTipAdvancedOnly”: false,
   “IsActive”: true
  }
 ]
}

Summary

Operation Name: Retrieve an IssueSubType4 by IssueSubType4 ID
Relative API Request Path: ~/api/v1/issuesubtypes4/{issueSubType4ID}
HTTP Verb: GET
Description: Retrieve a single IssueSubType4 by IssueSubType4 ID.

Operation Name: Retrieve all IssueSubTypes4
Relative API Request Path: ~/api /v1/issuesubtypes4
HTTP Verb: GET
Description: Retrieve a collection of currently defined IssueSubTypes4.

Retrieve an IssueSubType4 by IssueSubType4 ID

Description: This API method retrieves an IssueSubType4 from the Issuetrak data store for a specified IssueSubType4 ID. The “issueSubType4ID” parameter must correspond to an existing IssueSubType4. If there is no such IssueSubType4 ID, an error message will be returned with an HTTP response status code of 404.

When retrieving an IssueSubType4 using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueSubType4Name returned via the API method represents the IssueSubType4Name as stored within the Issuetrak database. Thus, when retrieving an IssueSubType4 created through the Issuetrak web interface where HTML encoding of the IssueSubType4Name is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadIssueSubType4DTO instance.

ReadIssueSubType4DTO {
     IssueSubType4ID (integer, optional),
     IssueSubType4Name (string, optional),
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     ParentID (integer, optional),
     DisplayOrder (number, optional),
     CreatedBy (string, optional),
     CreatedDate (string, optional): ISO 8601 string,
     ModifiedBy (string, optional),
     ModifiedDate (string, optional): ISO 8601 string,
     TrakTip (string, optional),
     IsTrakTipAdvancedOnly (boolean, optional),
     IsActive (boolean, optional)
}
CustomKeyValuePairDataElement {
     Key (string, optional),
     Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid IssueSubType4 ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent IssueSubType4: 404
• Invalid IssueSubType4 ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response Properties:

• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/issuesubtypes4/11

{
  “IssueSubType4ID”: 11,
  “IssueSubType4Name”: “Other”,
  “ExtensionData”: [],
  “Metadata”: [
  {
    “Key”: “APIVersion”,
    “Value”: “12.5”
  },
  {
    “Key”: “QueryDate”,
    “Value”: “2018-12-09T20:19:23.9695584Z”
  }
 ],
  “ParentID”: 7,
  “DisplayOrder”: 0,
  “CreatedBy”: “admin”
  “CreatedDate”: “2017-11-16T08:26:46.44”,
  “ModifiedBy”: null,
  “ModifiedDate”: null,
  “TrakTip”: “”,
  “IsTrakTipAdvancedOnly”: false,
  “IsActive”: true
}

Retrieve all IssueSubTypes4

Description: This API method retrieves a collection of all currently-defined IssueSubTypes4 from the Issuetrak data store.

When retrieving an IssueSubType4 using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the IssueSubType4Name returned via the API method represents the IssueSubType4Name as stored within the Issuetrak database. Thus, when retrieving an IssueSubType4 created through the Issuetrak web interface where HTML encoding of the IssueSubType4Name is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadIssueSubType4DTO instance.

QueryResultsContainer[ReadIssueSubType4DTO] {
     IsPageIndexZeroBased (boolean, optional),
     PageIndex (integer, optional),
     CountForPage (integer, optional),
     PageSize (integer, optional),
     TotalCount (integer, optional),
     Collection (Array[ReadIssueSubType4DTO], optional)
}
ReadIssueSubType4DTO {
     IssueSubType4ID (integer, optional),
     IssueSubType4Name (string, optional),
     ExtensionData (Array[CustomKeyValuePairDataElement], optional),
     Metadata (Array[CustomKeyValuePairDataElement], optional),
     ParentID (integer, optional),
     DisplayOrder (number, optional),
     CreatedBy (string, optional),
     CreatedDate (string, optional): ISO 8601 string,
     ModifiedBy (string, optional),
     ModifiedDate (string, optional): ISO 8601 string,
     TrakTip (string, optional),
     IsTrakTipAdvancedOnly (boolean, optional),
     IsActive (boolean, optional)
}
CustomKeyValuePairDataElement {
     Key (string, optional),
     Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent IssueSubType4: 404

Sample Request URL: ~/api /v1/issuesubtypes4/

{
  “IsPageIndexZeroBased”: true,
  “PageIndex”: 0,
  “CountForPage”: 1,
  “PageSize”: 2147483647,
  “TotalCount”: 1,
  “Collection”: [
  {
    “IssueSubType4ID”: 1,
    “IssueSubType4Name”: “Error”,
    “ExtensionData”: [],
    “Metadata”: [
   {
     “Key”: “APIVersion”,
     “Value”: “12.5”
   }
   {
     “Key”: “QueryDate”,
     “Value”: “2020-12-10T18:34:37.8439079Z”
   }
  ],
   “ParentID”: 3,
   “DisplayOrder”: 1,
   “CreatedBy”: “admin”,
   “CreatedDate”: “2017-11-16T08:26:46.44”,
   “ModifiedBy”: null,
   “ModifiedDate”: null,
   “TrakTip”: “”,
   “IsTrakTipAdvancedOnly”: false,
   “IsActive”: true
  }
 ]
}

Summary

Operation Name: Retrieve a Location by Location ID
Relative API Request Path: ~/api/v1/locations/{locationID}
HTTP Verb: GET
Description: Retrieve a single Location by Location ID.

Operation Name: Retrieve all Locations
Relative API Request Path: ~/api/v1/locations
HTTP Verb: GET
Description: Retrieve a collection of currently defined Locations.

Operation Name: Create a Location (Issuetrak 10.3+)
Relative API Request Path: ~/api/v1/locations
HTTP Verb: Post
Description: Create a new location with a specific LocationID.

Operation Name: Update a Location (Issuetrak 10.3+)
Relative API Request Path: ~/api/v1/locations
HTTP Verb: Put
Description: Update an existing location by specified LocationID.

Retrieve a Location by Location ID

Description: This API method retrieves a Location from the Issuetrak data store for a specified Location ID. The “locationID” parameter must correspond to an existing Location. If there is no such Location ID, an error message will be returned with an HTTP response status code of 404.

When retrieving an Location using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the LocationName returned via the API method represents the LocationName as stored within the Issuetrak database. Thus, when retrieving a Location created through the Issuetrak web interface where HTML encoding of the LocationName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadLocationDTO instance.

ReadLocationDTO
{
 ExtensionData (Array[CustomKeyValuePairDataElement]),
 Metadata (Array[CustomKeyValuePairDataElement]),
 LocationID (string),
 LocationName (string),
 Address1 (string),
 Address2 (string),
 City (string),
 State (string),
 Zip (string),
 Country (string),
 Phone (string),
 Phone2 (string),
 Fax (string),
 Email (string),
 ContactPerson (string),
 RegionID (integer),
 IsActive (boolean),
 UserDefined1 (string),
 UserDefined2 (string),
 UserDefined3 (string),
 OrganizationID (integer)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (object)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Location ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Location: 404
• Invalid Location ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/locations/11

{
  “ExtensionData”: [],
  “Metadata”: [
    {
      “Key”: “APIVersion”,
      “Value”: “12.5”
    },
    {
      “Key”: “QueryDate”,
      “Value”: “2020-12-15T18:39:46.5813112Z”
    }
  ],
  “LocationID”: “1test”,
  “LocationName”: “test”,
  “Address1”: “”,
  “Address2”: “”,
  “City”: “”,
  “State”: “”,
  “Zip”: “”,
  “Country”: “”,
  “Phone”: “”,
  “Phone2”: “”,
  “Fax”: “”,
  “Email”: “”,
  “ContactPerson”: “”,
  “RegionID”: null,
  “IsActive”: true,
  “UserDefined1”: “”,
  “UserDefined2”: “”,
  “UserDefined3”: “”,
  “OrganizationID”: 1
}

Retrieve all Locations

Description: This API method retrieves a collection of all currently-defined Locations from the Issuetrak data store.

When retrieving an Location using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the LocationName returned via the API method represents the LocationName as stored within the Issuetrak database. Thus, when retrieving a Location created through the Issuetrak web interface where HTML encoding of the LocationName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadLocationDTO instance.

QueryResultsContainer[ReadLocationDTO]
{
 IsPageIndexZeroBased (boolean),
 PageIndex (integer),
 CountForPage (integer),
 PageSize (integer),
 TotalCount (integer),
 Collection (Array[ReadLocationDTO])
}
ReadLocationDTO 
{
 ExtensionData (Array[CustomKeyValuePairDataElement]),
 Metadata (Array[CustomKeyValuePairDataElement]),
 LocationID (string),
 LocationName (string),
 Address1 (string),
 Address2 (string),
 City (string),
 State (string),
 Zip (string),
 Country (string),
 Phone (string),
 Phone2 (string),
 Fax (string),
 Email (string),
 ContactPerson (string),
 RegionID (integer),
 IsActive (boolean),
 UserDefined1 (string),
 UserDefined2 (string),
 UserDefined3 (string),
 OrganizationID (integer)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (object)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent Location: 404

Sample Request URL: ~/api/v1/locations

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
     {
       “Key”: “APIVersion”,
       “Value": “12.5”
     },
     {
       “Key”: “QueryDate”,
       “Value”;: “2020-12-15T18:39:11.8426562Z”
     }
   ],
   “LocationID”: “1test”,
   “LocationName”: “test”,
   “Address1”: “”,
   “Address2”: “”,
   “City”: “”,
   “State”: “”,
   “Zip”: “”,
   “Country”: “”,
   “Phone”: “”,
   “Phone2”: “”,
   “Fax”: “”,
   “Email”: “”,
   “ContactPerson”: “”,
   “RegionID”: null,
   “IsActive”: true,
   “UserDefined1”: “”,
   “UserDefined2”: “”,
   “UserDefined3”: “”,
   “OrganizationID”: 1
  }
 ]
}

Create a Location

Description: This API method creates a new Location associated with a specific LocationID within the Issuetrak data store. The CreateLocationDTO object conveys the properties of the new Location. Because LocationID values must be unique, the specified LocationID value must not currently exist. If the LocationID currently exists, an error message will be returned with a 400 HTTP status code.

The response code on success will be 201 (Created), and the response body will represent the text value representing the ID of the newly-created Location.

When creating a Location using the API, no special character encoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed.

All string properties have a maximum length of 50 unless specified otherwise.

CreateLocationDTO 
{
 LocationID (string),
 LocationName (string),
 Address1 (string),
 Address2 (string),
 City (string),
 State (string),
 Zip (string),
 Country (string),
 Phone (string),
 Phone2 (string),
 Fax (string),
 Email (string),
 ContactPerson (string),
 RegionID (integer),
 IsActive (boolean),
 UserDefined1 (string),
 UserDefined2 (string),
 UserDefined3 (string),
 OrganizationID (integer)
}

Request HTTP Verb: POST

Response Status Codes:

• Success: 201
• Invalid Data: 400 (Bad Request, e.g., a negative integer is supplied)
• Invalid Location DTO: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/locations

Update a Location

Description: This API method updates an existing Location associated with a specific LocationID within the Issuetrak data store. The UpdateLocationDTO object conveys the properties of the Location. If invalid data are supplied, an error message will be returned with a 400 HTTP status code.

The response code on success will be 200 (OK), and the response body will represent the text value representing the ID of the Location.

When updating a Location using the API, no special character encoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed.

All string properties have a maximum length of 50 unless specified otherwise.

UpdateLocationDTO
{
 LocationID (string),
 LocationName (string),
 Address1 (string),
 Address2 (string),
 City (string),
 State (string),
 Zip (string),
 Country (string),
 Phone (string),
 Phone2 (string),
 Fax (string),
 Email (string),
 ContactPerson (string),
 RegionID (integer),
 IsActive (boolean),
 UserDefined1 (string),
 UserDefined2 (string),
 UserDefined3 (string),
 OrganizationID (integer)
}

Request HTTP Verb: PUT

Response Status Codes:

• Success: 201
• Invalid Data: 400 (Bad Request, e.g., a negative integer is supplied)
• Invalid Location DTO: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/locations

Note: Menu Items are called "Custom Links" within the product UI.

Summary

Operation Name: Retrieve a MenuItem by MenuItem ID
Relative API Request Path: ~/api/v1/menuitems/{menuItemID}
HTTP Verb: GET
Description: Retrieve a single MenuItem by MenuItem ID.

Operation Name: Retrieve all MenuItems
Relative API Request Path: ~/api/v1/menuitems
HTTP Verb: GET
Description: Retrieve a collection of currently defined MenuItems.

Retrieve a MenuItem by MenuItem ID

Description: This API method retrieves a MenuItem from the Issuetrak data store for a specified MenuItem ID. The “MenuItemID” parameter must correspond to an existing MenuItem. If there is no such MenuItem ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a MenuItem using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the MenuItem Name returned via the API method represents the MenuItem Name as stored within the Issuetrak database. Thus, when retrieving a MenuItem created through the Issuetrak web interface where HTML encoding of the MenuItemName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadMenuItemDTO instance.

ReadMenuItemDTO
{
 ExtensionData (Array[CustomKeyValuePairDataElement]),
 Metadata (Array[CustomKeyValuePairDataElement]),
 MenuItemID (integer),
 MenuID (integer),
 MenuName (string),
 MenuPage (string)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (string)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid MenuItem ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Cause: 404
• Invalid MenuItem ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response Properties:

• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/menuitems/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “12.5”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2015-03-24T16:07:36.500667Z”
  }
 ],
 “MenuItemID”: 2,
 “MenuID”: 2,
 “MenuName”: “Submit Issue”,
 “MenuPage”: “CSIssue_Submit.asp”
}

Retrieve all MenuItems

Description: This API method retrieves a collection of all currently-defined MenuItems from the Issuetrak data store.

When retrieving a MenuItem using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the MenuItemName returned via the API method represents the MenuItemName as stored within the Issuetrak database. Thus, when retrieving a Cause created through the Issuetrak web interface where HTML encoding of the MenuItemName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadMenuItemDTO instance.

QueryResultsContainer[ReadMenuItemDTO]
{
 IsPageIndexZeroBased (boolean),
 PageIndex (integer),
 CountForPage (integer),
 PageSize (integer),
 TotalCount (integer),
 Collection (Array[ReadMenuItemDTO])
}
ReadMenuItemDTO
{
 ExtensionData (Array[CustomKeyValuePairDataElement]),
 Metadata (Array[CustomKeyValuePairDataElement]),
 MenuItemID (integer),
 MenuID (integer),
 MenuName (string),
 MenuPage (string)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (string)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent MenuItem: 404

Sample Request URL: ~/api/v1/menuitems/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “12.5”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2015-03-24T16:08:21.0863244Z”
    }
   ],
   “MenuItemID”: 2,
   “MenuID”: 2,
   “MenuName”: “Submit Issue”,
   “MenuPage”: “CSIssue_Submit.asp”
  }
 ]
}

Summary

Operation Name: Retrieve a Note by Note ID
Relative API Request Path: ~/api/v1/notes/{noteID}
HTTP Verb: GET
Description: Retrieve a single Note from the database by Note ID.

Operation Name: Retrieve a Collection of Notes by Issue Number
Relative API Request Path: ~/api/v1/notes/issue/{issueNumber}
HTTP Verb: GET
Description: Retrieve a collection of Notes from the database by their associated issueNumber.

Operation Name: Create a Note for an Issue
Relative API Request Path: ~/api/v1/notes
HTTP Verb: POST
Description: Create a new Note for an Issue.

Retrieve a Note by Note ID

Description: This API method retrieves a Note from the Issuetrak data store for a specified Note ID value. The “noteID” parameter must correspond to an existing Note. If there is no such Note ID, an error message will be returned with an HTTP response status code of 400.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadNoteDTO instance.

When retrieving a Note using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the NoteText returned via the API method represents the NoteText as stored within the Issuetrak database. Thus, when retrieving a Note created through the Issuetrak web interface where HTML encoding of the NoteText is performed, the API consumer may desire to perform additional client-side decoding.

ReadNoteDTO
{
 ExtensionData (array[KeyValuePair[String,Object]]),
 Metadata (array[KeyValuePair[String,Object]]),
 NoteID (integer),
 IssueNumber (integer),
 CreatedDate (ISO 8601 string),
 CreatedBy (string),
 ModifiedBy (string),
 ModifiedDate (ISO 8601 string),
 NoteText (string),
 IsPrivate (boolean),
 IsRichText (boolean)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (object)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Note ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Note: 404
• Invalid Note ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response Properties:

• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/notes/102

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “12.5”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2014-10-08T16:06:58.6146552Z”
  }
 ],
 “NoteID”: 102,
 “IssueNumber”: 1,
 “CreatedDate”: “2011-06-22T18:55:30.47”,
 “CreatedBy”: “Admin”,
 “ModifiedBy”: “Admin”,
 “ModifiedDate”: “2014-08-22T12:11:30.063”,
 “NoteText”: “What I've done”,
 “IsPrivate”: true,
 “IsRichText”: true
}

Retrieve a Collection of Notes by Issue Number

Description: Description: This API method retrieves a collection of Attachment from the Issuetrak data store for the specified Issue Number. The “issueNumber” parameter must correspond to an existing Issue. If there is no such IssueNumber, an error message will be returned with an HTTP response status code of 400.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadNoteDTO instance.

When retrieving a Note using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the NoteText returned via the API method represents the NoteText as stored within the Issuetrak database. Thus, when retrieving a Note created through the Issuetrak web interface where HTML encoding of the NoteText is performed, the API consumer may desire to perform additional client-side decoding.

QueryResultsContainer[ReadIssueTypeDTO]
{
 IsPageIndexZeroBased (boolean),
 PageIndex (integer),
 CountForPage (integer),
 PageSize (integer),
 TotalCount (integer),
 Collection (array[ReadIssueSubType3DTO])
}
ReadNoteDTO
{
 ExtensionData (array[KeyValuePair[String,Object]]),
 Metadata (array[KeyValuePair[String,Object]]),
 NoteID (integer),
 IssueNumber (integer),
 CreatedDate (ISO 8601 string),
 CreatedBy (string),
 ModifiedBy (string),
 ModifiedDate (ISO 8601 string),
 NoteText (string),
 IsPrivate (boolean),
 IsRichText (boolean)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (object)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Issue Number: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Issue: 400
• Invalid Issue Number: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/notes/issue/6

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “12.5”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2014-10-08T16:24:53.1827312Z”
    }
   ],
   “NoteID”: 140,
   “IssueNumber”: 6,
   “CreatedDate”: “2011-06-23T10:55:37.81”,
   “CreatedBy”: “TestUser”,
   “ModifiedBy”: null,
   “ModifiedDate”: null,
   “NoteText”: “No action needed”,
   “IsPrivate”: true,
   “IsRichText”: true
  }
 ]
}

Create a Note for an Issue

Description: This API method creates a new Note associated with a specific Issue (identified by IssueNumber) within the Issuetrak data store. The CreateNoteDTO object conveys the properties of the new Note. Because Notes are associated with Issues, the IssueNumber property of the DTO must correspond to an existing Issue. If there is no such IssueNumber, an error message will be returned with a 400 HTTP status code.

The response code on success will be 201 (Created), and the response body will represent the 32-bit integer value representing the ID of the newly-created Note.

When creating a Note using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. This deviates from the process when creating a Note through the Issuetrak web interface where HTML encoding of the NoteText is performed.

CreateNoteDTO
{
 IssueNumber (integer),
 CreatedDate (ISO 8601 string),
 CreatedBy (string),
 ShouldSuppressEmailForCreateOperation (boolean),
 NoteText (string),
 IsPrivate (boolean),
 IsRichText (boolean)
}

Request HTTP Verb: POST

Response Status Codes:

• Success: 201 (Created)
• Invalid Data: 400
• Non-existent Issue: 400

Sample Request URL: ~/api/v1/notes/

{
 “IssueNumber”: 6,
 “CreatedDate”: “2014-01-01T11:30:10.0000000”,
 “CreatedBy”: “Admin”,
 “ShouldSuppressEmailForCreateOperation”: false,
 “NoteText”: “This is a test public note.”,
 “IsPrivate”: false,
 “IsRichText”: false
}

Sample Response HTTP Status Code: 201

Sample Response Body: 123101 (represents the newly-created Note ID)

Summary

Operation Name: Retrieve an Organization by Organization ID
Relative API Request Path: ~/api/v1/organizations/{organizationID}
HTTP Verb: GET
Description: Retrieve a single Organization by Organization ID.

Operation Name: Retrieve all Organizations
Relative API Request Path: ~/api/v1/organizations
HTTP Verb: GET
Description: Retrieve a collection of currently defined Organizations.

Operation Name: Create an Organization
Relative API Request Path: ~/api/v1/organizations
HTTP Verb: POST
Description: Creates a new Organization associated with a specific OrganizationID.

Operation Name: Update an Organization
Relative API Request Path: ~/api/v1/organizations
HTTP Verb: PUT
Description: Updates an existing Organization associated with a specific OrganizationID.

Retrieve an Organization by Organization ID

This API method retrieves an Organization from the Issuetrak data store for a specified Organization ID. The organizationID parameter must correspond to an existing Organization. If there is no such Organization ID, an error message will be returned with an HTTP response status code of 404.

When retrieving an Organization using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the OrganizationName returned via the API method represents the OrganizationName as stored within the Issuetrak database. Thus, when retrieving an Organization created through the Issuetrak web interface where HTML encoding of the OrganizationName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadOrganizationDTO instance.

ReadOrganizationDTO
 {
ExtensionData (Array[CustomKeyValuePairDataElement]),
Metadata (Array[CustomKeyValuePairDataElement]),
OrganizationID (integer),
CreatedBy (string),
CreatedDate (string): ISO 8601 string,
ModifiedBy (string),
ModifiedDate (string): ISO 8601 string,
IssueTrakUser (string),
OrganizationName (string),
Address1 (string),
Address2 (string),
City (string),
State (string),
Zip (string),
Phone (string),
WebAddress (string),
IsInternalOnly (boolean),
UserDefined1 (string),
UserDefined2 (string),
UserDefined3 (string),
UserDefined4 (string),
UserDefined5 (string),
UserDefinedID1 (integer),
UserDefinedID2 (integer),
UserDefinedID3 (integer),
UserDefinedID4 (integer),
UserDefinedID5 (integer),
UserDefinedDate1 (string): ISO 8601 string,
UserDefinedDate2 (string): ISO 8601 string,
Note (string),
ContactPerson (string),
Email (string),
BillingReference (string),
TitleLogoLeftLink (string),
TitleLogoRightLink (string),
SiteTitle (string),
EmailFromName (string),
EmailFromAddress (string)
}
CustomKeyValuePairDataElement 
{
Key (string, optional),
Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Organization ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Organization: 404
• Invalid Organization ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/organizations/11

{
  "ExtensionData": [
    {
      "Key": "string",
      "Value": {}
    }
  ],
  "Metadata": [
    {
      "Key": "string",
      "Value": {}
    }
  ],
  "OrganizationID": 0,
  "CreatedBy": "string",
  "CreatedDate": "string",
  "ModifiedBy": "string",
  "ModifiedDate": "string",
  "IssueTrakUser": "string",
  "OrganizationName": "string",
  "Address1": "string",
  "Address2": "string",
  "City": "string",
  "State": "string",
  "Zip": "string",
  "Phone": "string",
  "WebAddress": "string",
  "IsInternalOnly": true,
  "UserDefined1": "string",
  "UserDefined2": "string",
  "UserDefined3": "string",
  "UserDefined4": "string",
  "UserDefined5": "string",
  "UserDefinedID1": 0,
  "UserDefinedID2": 0,
  "UserDefinedID3": 0,
  "UserDefinedID4": 0,
  "UserDefinedID5": 0,
  "UserDefinedDate1": "string",
  "UserDefinedDate2": "string",
  "Note": "string",
  "ContactPerson": "string",
  "Email": "string",
  "BillingReference": "string",
  "TitleLogoLeftLink": "string",
  "TitleLogoRightLink": "string",
  "SiteTitle": "string",
  "EmailFromName": "string",
  "EmailFromAddress": "string"
}

Retrieve all Organizations

This API method retrieves a collection of all currently-defined Organizations from the Issuetrak data store.

When retrieving an Organization using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the OrganizationName returned via the API method represents the OrganizationName as stored within the Issuetrak database. Thus, when retrieving an Organization created through the Issuetrak web interface where HTML encoding of the OrganizationName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadOrganizationDTO instance.

 QueryResultsContainer[ReadOrganizationDTO] {
IsPageIndexZeroBased (boolean, optional),
PageIndex (integer, optional),
CountForPage (integer, optional),
PageSize (integer, optional),
TotalCount (integer, optional),
Collection (Array[ReadOrganizationDTO], optional)
}ReadOrganizationDTO {
ExtensionData (Array[CustomKeyValuePairDataElement]),
Metadata (Array[CustomKeyValuePairDataElement]),
OrganizationID (integer),
CreatedBy (string),
CreatedDate (string): ISO 8601 string,
ModifiedBy (string),
ModifiedDate (string): ISO 8601 string,
IssueTrakUser (string),
OrganizationName (string),
Address1 (string),
Address2 (string),
City (string),
State (string),
Zip (string),
Phone (string),
WebAddress (string),
IsInternalOnly (boolean),
UserDefined1 (string),
UserDefined2 (string),
UserDefined3 (string),
UserDefined4 (string),
UserDefined5 (string),
UserDefinedID1 (integer),
UserDefinedID2 (integer),
UserDefinedID3 (integer),
UserDefinedID4 (integer),
UserDefinedID5 (integer),
UserDefinedDate1 (string): ISO 8601 string,
UserDefinedDate2 (string): ISO 8601 string,
Note (string),
ContactPerson (string),
Email (string),
BillingReference (string),
TitleLogoLeftLink (string),
TitleLogoRightLink (string),
SiteTitle (string),
EmailFromName (string),
EmailFromAddress (string)
}CustomKeyValuePairDataElement {
Key (string, optional),
Value (object, optional)
} 

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent Organization: 404

Sample Request URL: ~/api/v1/organizations/

{
  "IsPageIndexZeroBased": true,
  "PageIndex": 0,
  "CountForPage": 0,
  "PageSize": 0,
  "TotalCount": 0,
  "Collection": [
    {
      "ExtensionData": [
        {
          "Key": "string",
          "Value": {}
        }
      ],
      "Metadata": [
        {
          "Key": "string",
          "Value": {}
        }
      ],
      "OrganizationID": 0,
      "CreatedBy": "string",
      "CreatedDate": "string",
      "ModifiedBy": "string",
      "ModifiedDate": "string",
      "IssueTrakUser": "string",
      "OrganizationName": "string",
      "Address1": "string",
      "Address2": "string",
      "City": "string",
      "State": "string",
      "Zip": "string",
      "Phone": "string",
      "WebAddress": "string",
      "IsInternalOnly": true,
      "UserDefined1": "string",
      "UserDefined2": "string",
      "UserDefined3": "string",
      "UserDefined4": "string",
      "UserDefined5": "string",
      "UserDefinedID1": 0,
      "UserDefinedID2": 0,
      "UserDefinedID3": 0,
      "UserDefinedID4": 0,
      "UserDefinedID5": 0,
      "UserDefinedDate1": "string",
      "UserDefinedDate2": "string",
      "Note": "string",
      "ContactPerson": "string",
      "Email": "string",
      "BillingReference": "string",
      "TitleLogoLeftLink": "string",
      "TitleLogoRightLink": "string",
      "SiteTitle": "string",
      "EmailFromName": "string",
      "EmailFromAddress": "string"
    }
  ]
}

Create an Organization

This API method creates a new Organization associated with a specific OrganizationID within the Issuetrak data store. The CreateOrganizationModel object conveys the properties of the new Organization.

The response code on success will be 201 (Created), and the response body will represent the text value representing the ID of the newly-created Organization.

When creating a Organization using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed.

All string properties have a maximum length of 50 unless specified otherwise.

CreateOrganizationModel {
 OrganizationName (string),
 Address1 (string),
 Address2 (string),
 City (string),
 State (string),
 Zip (string),
 Phone (string),
 WebAddress (string),
 IsInternalOnly (boolean),
 UserDefined1 (string),
 UserDefined2 (string),
 UserDefined3 (string),
 UserDefined4 (string),
 UserDefined5 (string),
 UserDefinedID1 (integer),
 UserDefinedID2 (integer),
 UserDefinedID3 (integer),
 UserDefinedID4 (integer),
 UserDefinedID5 (integer),
 UserDefinedDate1 (string): ISO 8601 string ,
 UserDefinedDate2 (string): ISO 8601 string ,
 Note (string),
 ContactPerson (string),
 Email (string),
 BillingReference (string),
 TitleLogoLeftLink (string),
 TitleLogoRightLink (string),
 SiteTitle (string),
 EmailFromName (string),
 EmailFromAddress (string)
}

Request HTTP Verb: POST

Response Status Codes:

• Success: 201
• Invalid Data: 400 (Bad Request, e.g., a negative integer is supplied)
• Invalid Organization DTO: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/organizations

Update an Organization

This API method updates an existing Organization associated with a specific OrganizationID within the Issuetrak data store. The UpdateOrganizationModel object conveys the properties of the Organization. If invalid data are supplied, an error message will be returned with a 400 HTTP status code.

The response code on success will be 200 (OK), and the response body will represent the text value representing the ID of the Organization.

When updating a Organization using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed.

All string properties have a max length of 50 unless specified otherwise

UpdateOrganizationModel {
 OrganizationID (integer),
 IssueTrakUser (string),
 OrganizationName (string),
 Address1 (string),
 Address2 (string),
 City (string),
 State (string),
 Zip (string),
 Phone (string),
 WebAddress (string),
 IsInternalOnly (boolean),
 UserDefined1 (string),
 UserDefined2 (string),
 UserDefined3 (string),
 UserDefined4 (string),
 UserDefined5 (string),
 UserDefinedID1 (integer),
 UserDefinedID2 (integer),
 UserDefinedID3 (integer),
 UserDefinedID4 (integer),
 UserDefinedID5 (integer),
 UserDefinedDate1 (string): ISO 8601 string ,
 UserDefinedDate2 (string): ISO 8601 string ,
 Note (string),
 ContactPerson (string),
 Email (string),
 BillingReference (string),
 TitleLogoLeftLink (string),
 TitleLogoRightLink (string),
 SiteTitle (string),
 EmailFromName (string),
 EmailFromAddress (string)
}

Request HTTP Verb: PUT

Response Status Codes:

• Success: 200
• Invalid Data: 400 (Bad Request, e.g., a negative integer is supplied)
• Invalid Organization DTO: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/organizations

Summary

Operation Name: Retrieve a Priority by Priority ID
Relative API Request Path: ~/api/v1/priorities/{priorityID}
HTTP Verb: GET
Description: Retrieve a single Priority by Priority ID.

Operation Name: Retrieve all Priorities
Relative API Request Path: ~/api/v1/priorities
HTTP Verb: GET
Description: Retrieve a collection of currently defined Priorities.

Retrieve a Priority by Priority ID

This API method retrieves a Priority from the Issuetrak data store for a specified Priority ID. The PriorityID parameter must correspond to an existing Priority. If there is no such Priority ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a Priority using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the PriorityName returned via the API method represents the PriorityName as stored within the Issuetrak database. Thus, when retrieving a Priority created through the Issuetrak web interface where HTML encoding of the PriorityName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadPriorityDTO instance.

ReadPriorityDTO
{
 ExtensionData (array[KeyValuePair[String,Object]]),
 Metadata (array[KeyValuePair[String,Object]]),
 PriorityID (integer),
 PriorityName (string),
 DisplayOrder (number),
 Message (string),
 Color (string)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Priority ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Priority: 404
• Invalid Priority ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/priorities/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “v1”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2014-12-22T18:18:39.4719339Z”
  }
 ],
 “PriorityID”: 1,
 “PriorityName”: “High”,
 “DisplayOrder”: 2,
 “Message”: null,
 “Color”: null
}

Retrieve all Priorities

This API method retrieves a collection of all currently-defined Priority entities from the Issuetrak data store.

When retrieving a Priority using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the PriorityName returned via the API method represents the PriorityName as stored within the Issuetrak database. Thus, when retrieving a Priority created through the Issuetrak web interface where HTML encoding of the PriorityName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadPriorityDTO instance.

{
 “IsPageIndexZeroBased”: false,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    “KeyValuePair[String,Object]”
   ],
   “Metadata”: [
    “KeyValuePair[String,Object]”
   ],
   “PriorityID”: 0,
   “PriorityName”: "",
   “DisplayOrder”: 0,
   “Message”: "",
   “Color”: ""
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent Priority: 404

Sample Request URL: ~/api/v1/priorities/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 4,
 “PageSize”: 2147483647,
 “TotalCount”: 4,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “v1”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2014-12-22T18:20:15.7665624Z”
    }
   ],
   “PriorityID”: 1,
   “PriorityName”: “High”,
   “DisplayOrder”: 2,
   “Message”: null,
   “Color”: null
  }
 ]
}

Summary

Operation Name: Retrieve a Project by Project ID
Relative API Request Path: ~/api/v1/projects/{projectID}
HTTP Verb: GET
Description: Retrieve a single Project by Project ID.

Operation Name: Retrieve all Projects
Relative API Request Path: ~/api/v1/projects
HTTP Verb: GET
Description: Retrieve a collection of currently defined Projects.

Retrieve a Project by Project ID

Description: This API method retrieves a Project from the Issuetrak data store for a specified Project ID. The ProjectID parameter must correspond to an existing Project. If there is no such Project ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a Project using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the Title returned via the API method represents the Title as stored within the Issuetrak database. Thus, when retrieving a Project created through the Issuetrak web interface where HTML encoding of the Title is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadProjectDTO instance.

ReadProjectDTO
{
 ExtensionData (array[KeyValuePair[String,Object]]),
 Metadata (array[KeyValuePair[String,Object]]),
 ProjectID (integer),
 ProjectNumber (string),
 Title (string),
 Description (string),
 ProjectManager (string),
 OrganizationID (integer),
 LocationID (string),
 Status (string),
 CloseDate (ISO 8601 string),
 OpenDate (ISO 8601 string),
 TargetDate (ISO 8601 string),
 IsExclusive (boolean),
 CategoryID (integer),
 RequiredByDate (ISO 8601 string),
 EstimatedHours (number),
 ActualHours (number),
 EstimatedBudget (number),
 ActualBudget (number),
 PercentCompleted (number),
 SubStatusID (integer)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Project ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Project: 404
• Invalid Project ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/projects/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “v1”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2014-12-24T16:13:38.6850608Z”
  }
 ],
 “ProjectID”: 1,
 “ProjectNumber”: “100”,
 “Title”: “Test-Project”,
 “Description”: “This is a test project.”,
 “ProjectManager”: null,
 “OrganizationID”: 2,
 “LocationID”: “HQ”,
 “Status”: “Open”,
 “CloseDate”: null,
 “OpenDate”: “2014-12-23T13:30:00”,
 “TargetDate”: null,
 “IsExclusive”: false,
 “CategoryID”: null,
 “RequiredByDate”: null,
 “EstimatedHours”: 10,
 “ActualHours”: null,
 “EstimatedBudget”: 2500,
 “ActualBudget”: null,
 “PercentCompleted”: null,
 “SubStatusID”: null
}

Retrieve all Projects

This API method retrieves a collection of all currently-defined Project entities from the Issuetrak data store.

When retrieving a Project using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the Title returned via the API method represents the Title as stored within the Issuetrak database. Thus, when retrieving a Project created through the Issuetrak web interface where HTML encoding of the Title is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadProjectDTO instance.

{
 “IsPageIndexZeroBased”: false,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    “KeyValuePair[String,Object]”
   ],
   “Metadata”: [
    “KeyValuePair[String,Object]”
   ],
   “ProjectID”: 0,
   “ProjectNumber”: "",
   “Title”: "",
   “Description”: "",
   “ProjectManager”: "",
   “OrganizationID”: 0,
   “LocationID”: "",
   “Status”: "",
   “CloseDate”: “ISO 8601 string”,
   “OpenDate”: “ISO 8601 string”,
   “TargetDate”: “ISO 8601 string”,
   “IsExclusive”: false,
   “CategoryID”: 0,
   “RequiredByDate”: “ISO 8601 string”,
   “EstimatedHours”: 0,
   “ActualHours”: 0,
   “EstimatedBudget”: 0,
   “ActualBudget”: 0,
   “PercentCompleted”: 0,
   “SubStatusID”: 0
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent Project: 404

Sample Request URL: ~/api/v1/projects/1

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “v1”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2014-12-24T16:14:09.4182428Z”
    }
   ],
   “ProjectID”: 1,
   “ProjectNumber”: “100”,
   “Title”: “Test-Project”,
   “Description”: “This is a test project.”,
   “ProjectManager”: null,
   “OrganizationID”: 2,
   “LocationID”: “HQ”,
   “Status”: “Open”,
   “CloseDate”: null,
   “OpenDate”: “2014-12-23T13:30:00”,
   “TargetDate”: null,
   “IsExclusive”: false,
   “CategoryID”: null,
   “RequiredByDate”: null,
   “EstimatedHours”: 10,
   “ActualHours”: null,
   “EstimatedBudget”: 2500,
   “ActualBudget”: null,
   “PercentCompleted”: null,
   “SubStatusID”: null
  }
 ]
}

Summary

Operation Name: Retrieve a ServiceLevel by ServiceLevel ID
Relative API Request Path: ~/api/v1/servicelevels/{serviceLevelID}
HTTP Verb: GET
Description: Retrieve a single ServiceLevel by ServiceLevel ID.

Operation Name: Retrieve all ServiceLevels
Relative API Request Path: ~/api/v1/servicelevels
HTTP Verb: GET
Description: Retrieve a collection of currently defined ServiceLevels.

Retrieve a ServiceLevel by ServiceLevel ID

This API method retrieves a ServiceLevel from the Issuetrak data store for a specified ServiceLevel ID. The serviceLevelID parameter must correspond to an existing ServiceLevel. If there is no such ServiceLevel ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a ServiceLevel using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the ServiceLevelName returned via the API method represents the ServiceLevelName as stored within the Issuetrak database. Thus, when retrieving a ServiceLevel created through the Issuetrak web interface where HTML encoding of the ServiceLevelName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadServiceLevelDTO instance.

ReadServiceLevelDTO
{
 ExtensionData (array[CustomKeyValuePairDataElement]),
 Metadata (array[CustomKeyValuePairDataElement]),
 ServiceLevelID (integer),
 ServiceLevel (string),
 DisplayOrder (number),
 Comment (string),
 IsInactive (boolean)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (string)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid ServiceLevel ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Cause: 404
• Invalid ServiceLevel ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/servicelevels/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “v1”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2015-02-09T18:14:06.1227057Z”
  }
 ],
 “ServiceLevelID”: 1,
 “ServiceLevel”: “Default Service Level”,
 “DisplayOrder”: 1,
 “Comment”: “Default Service Level”,
 “IsInactive”: null
}

Retrieve all ServiceLevels

This API method retrieves a collection of all currently-defined ServiceLevels from the Issuetrak data store.

When retrieving a ServiceLevel using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the ServiceLevelName returned via the API method represents the ServiceLevelName as stored within the Issuetrak database. Thus, when retrieving a Cause created through the Issuetrak web interface where HTML encoding of the ServiceLevelName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadServiceLevelDTO instance.

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    {
     “Key”: "",
     “Value”: ""
    }
   ],
   “Metadata”: [
    {
     “Key”: "",
     “Value”: ""
    }
   ],
   “ServiceLevelID”: 0,
   “ServiceLevel”: "",
   “DisplayOrder”: 0,
   “Comment”: "",
   “IsInactive”: false
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent ServiceLevel: 404

Sample Request URL: ~/api/v1/servicelevels/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “v1”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2015-02-09T18:14:57.5088438Z”
    }
   ],
   “ServiceLevelID”: 1,
   “ServiceLevel”: “Default Service Level”,
   “DisplayOrder”: 1,
   “Comment”: “Default Service Level”,
   “IsInactive”: null
  }
 ]
}

Summary

Operation Name: Retrieve a ServiceLevelAgreement by ServiceLevelAgreement ID
Relative API Request Path: ~/api/v1/servicelevelagreements/{serviceLevelAgreementID}
HTTP Verb: GET
Description: Retrieve a single ServiceLevelAgreement by ServiceLevelAgreement ID.

Operation Name: Retrieve all ServiceLevelAgreements
Relative API Request Path: ~/api/v1/servicelevelagreements
HTTP Verb: GET
Description: Retrieve a collection of currently defined ServiceLevelAgreements.

Retrieve a ServiceLevelAgreement by ServiceLevelAgreement ID

Description: This API method retrieves a ServiceLevelAgreement from the Issuetrak data store for a specified ServiceLevelAgreement ID. The “serviceLevelAgreementID” parameter must correspond to an existing ServiceLevelAgreement. If there is no such ServiceLevelAgreement ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a ServiceLevelAgreement using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the ServiceLevelAgreement Name returned via the API method represents the ServiceLevelAgreement Name as stored within the Issuetrak database. Thus, when retrieving a ServiceLevelAgreement created through the Issuetrak web interface where HTML encoding of the ServiceLevelAgreementName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadServiceLevelAgreementDTO instance.

  ReadServiceLevelAgreementDTO 
  { 
  ExtensionData (array[CustomKeyValuePairDataElement]),
  Metadata (array[CustomKeyValuePairDataElement]),
  ServiceLevelAgreementID (integer),
  ServiceLevelID (integer),
  ClientType (string),
  ClientID (integer),
  ServiceStartDate (ISO 8601 string),
  ServiceEndDate (ISO 8601 string),
  DefaultSeverityID (integer)
  } 
  CustomKeyValuePairDataElement 
  { 
  Key (string),
  Value (string)
  }
  
  

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid ServiceLevelAgreement ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Cause: 404
• Invalid ServiceLevelAgreement ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response DTO Property Notes:

• The ExtensionData property is not used in version 1 of the API.
• The Metadata property provides a key / value collection of additional data about the API operation and / or the response body.

Sample Request URL: ~/api/v1/servicelevelagreements/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “v1”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2015-02-10T15:14:13.9131436Z”
  }
 ],
 “ServiceLevelAgreementID”: 1,
 “ServiceLevelID”: 1,
 “ClientType”: “Org”,
 “ClientID”: 1,
 “ServiceStartDate”: “2015-01-01T00:00:00”,
 “ServiceEndDate”: “2050-12-31T00:00:00”,
 “DefaultSeverityID”: 1
}

Retrieve all ServiceLevelAgreements

Description: This API method retrieves a collection of all currently-defined ServiceLevelAgreement from the Issuetrak data store.

When retrieving a ServiceLevelAgreement using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the ServiceLevelAgreementName returned via the API method represents the ServiceLevelAgreementName as stored within the Issuetrak database. Thus, when retrieving a Cause created through the Issuetrak web interface where HTML encoding of the ServiceLevelAgreementName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadServiceLevelAgreementDTO instance.

{
 “IsPageIndexZeroBased”: false,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    {
     “Key”: "",
     “Value”: "" 
    }
   ],
   “Metadata”: [
    {
     “Key”: "",
     “Value”: ""
    }
   ],
   “ServiceLevelAgreementID”: 0,
   “ServiceLevelID”: 0,
   “ClientType”: "",
   “ClientID”: 0,
   “ServiceStartDate”: “ISO 8601 string”,
   “ServiceEndDate”: “ISO 8601 string”,
   “DefaultSeverityID”: 0
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent ServiceLevelAgreement: 404

Response DTO Property Notes:

• The IsPageIndexZeroBased property value is always true. This property is included for use in future API versions.
• The PageIndex property value is always 0. This property is included for use in future API versions.
• The CountForPage property value is always the same as TotalCount. This property is included for use in future API versions.
• The PageSize property value is always the maximum value for a signed, 32-bit integer. This property is included for use in future API versions.
• The TotalCount property value is the number of records returned in the collection.
• The Collection property is an array containing the ReadServiceLevelAgreementDTO objects returned.
• The ExtensionData property is not implemented in v1 of the API.

Sample Request URL: ~/api/v1/servicelevelagreements/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “v1”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2015-02-10T15:15:17.5675084Z”
    }
   ],
   “ServiceLevelAgreementID”: 1,
   “ServiceLevelID”: 1,
   “ClientType”: “Org”,
   “ClientID”: 1,
   “ServiceStartDate”: “2015-01-01T00:00:00”,
   “ServiceEndDate”: “2050-12-31T00:00:00”,
   “DefaultSeverityID”: 1
  }
 ]
}

Summary

Operation Name: Retrieve a ServiceLevelSeverity by ServiceLevelSeverity ID
Relative API Request Path: ~/api/v1/servicelevelseverities/{severityID}
HTTP Verb: GET
Description: Retrieve a single ServiceLevelSeverity by ServiceLevelSeverity ID.

Operation Name: Retrieve all ServiceLevelSeverities
Relative API Request Path: ~/api/v1/servicelevelseverities
HTTP Verb: GET
Description: Retrieve a collection of currently defined ServiceLevelSeverities.

Retrieve a ServiceLevelSeverity by ServiceLevelSeverity ID

This API method retrieves a ServiceLevelSeverity from the Issuetrak data store for a specified ServiceLevelSeverity ID. The severityID parameter must correspond to an existing ServiceLevelSeverity. If there is no such ServiceLevelSeverity ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a ServiceLevelSeverity using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the ServiceLevelSeverityName returned via the API method represents the ServiceLevelSeverityName as stored within the Issuetrak database. Thus, when retrieving a ServiceLevelSeverity created through the Issuetrak web interface where HTML encoding of the ServiceLevelSeverityName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadServiceLevelSeverityDTO instance.

ReadServiceLevelSeverityDTO
{
 ExtensionData (array[CustomKeyValuePairDataElement]),
 Metadata (array[CustomKeyValuePairDataElement]),
 SeverityID (integer),
 Severity (string),
 SeverityDescription (string),
 DisplayOrder (number)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (string)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid ServiceLevelSeverity ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent ServiceLevelSeverity: 404
• Invalid ServiceLevelSeverity ID: 422 (Unprocessable Enatity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/servicelevelseverities/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “v1”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2015-02-09T14:07:58.2787766Z”
  }
 ],
 “SeverityID”: 1,
 “Severity”: “Low”,
 “SeverityDescription”: “Low Severity”,
 “DisplayOrder”: 1
}

Retrieve all ServiceLevelSeverities

This API method retrieves a collection of all currently-defined ServiceLevelSeverities from the Issuetrak data store.

When retrieving a ServiceLevelSeverity using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the ServiceLevelSeverityName returned via the API method represents the ServiceLevelSeverityName as stored within the Issuetrak database. Thus, when retrieving a Cause created through the Issuetrak web interface where HTML encoding of the ServiceLevelSeverityName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadServiceLevelSeverityDTO instance.

{
 “IsPageIndexZeroBased”: false,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    {
     “Key”: "",
     “Value”: ""
    }
   ],
   “Metadata”: [
    {
     “Key”: "",
     “Value”: ""
    }
   ],
   “SeverityID”: 0,
   “Severity”: "",
   “SeverityDescription”: "",
   “DisplayOrder”: 0
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent ServiceLevelSeverities: 404

Sample Request URL: ~/api/v1/servicelevelseverities/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “v1”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2015-02-09T14:32:17.9301759Z”
    }
   ],
   “SeverityID”: 1,
   “Severity”: “Low”,
   “SeverityDescription”: “Low Severity”,
   “DisplayOrder”: 1
  },
 ]
}

Summary

Operation Name: Retrieve a ServiceLevelTerm by ServiceLevelTerm ID
Relative API Request Path: ~/api/v1/servicelevelterms/{serviceLevelTermID}
HTTP Verb: GET
Description: Retrieve a single ServiceLevelTerm by ServiceLevelTerm ID.

Operation Name: Retrieve all ServiceLevelTerms
Relative API Request Path: ~/api/v1/servicelevelterms
HTTP Verb: GET
Description: Retrieve a collection of currently defined ServiceLevelTerms.

Retrieve a ServiceLevelTerm by ServiceLevelTerm ID

Description: This API method retrieves a ServiceLevelTerm from the Issuetrak data store for a specified ServiceLevelTerm ID. The “serviceLevelTermID” parameter must correspond to an existing ServiceLevelTerm. If there is no such ServiceLevelTerm ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a ServiceLevelTerm using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the ServiceLevelTerm Name returned via the API method represents the ServiceLevelTerm Name as stored within the Issuetrak database. Thus, when retrieving a ServiceLevelTerm created through the Issuetrak web interface where HTML encoding of the ServiceLevelTermName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadServiceLevelTermDTO instance.

ReadServiceLevelTermDTO
{
 ExtensionData (array[CustomKeyValuePairDataElement]),
 Metadata (array[CustomKeyValuePairDataElement]),
 ServiceLevelTermID (integer),
 ServiceLevelID (integer),
 SeverityID (integer),
 ResponseTime (integer),
 ResolutionTime (integer),
 CoverageStartDay (integer),
 CoverageEndDay (integer),
 Comment (string),
 CanUseSystemOffDates (boolean)
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (string)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid ServiceLevelTerm ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Cause: 404
• Invalid ServiceLevelTerm ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Response DTO Property Notes:

• The ExtensionData property is not used in version 1 of the API.
• The Metadata property provides a key / value collection of additional data about the API operation and/or the response body.
• The CoverageStartDay property is an Int32 value in the range 1 to 7 with 1 representing Monday, 2 representing Tuesday, …, 7 representing Sunday.
• The CoverageEndDay property is an Int32 value in the range 1 to 7 with 1 representing Monday, 2 representing Tuesday, …, 7 representing Sunday.

Sample Request URL: ~/api/v1/servicelevelterms/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “v1”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2015-02-09T15:46:07.8521238Z” 
  }
 ],
 “ServiceLevelTermID”: 1,
 “ServiceLevelID”: 1,
 “SeverityID”: 3,
 “ResponseTime”: 10,
 “ResolutionTime”: 30,
 “CoverageStartTime”: “1899-12-30T00:00:00”,
 “CoverageEndTime”: “1899-12-30T23:59:00”,
 “CoverageStartDay”: 1,
 “CoverageEndDay”: 7,
 “Comment”: “Test Comment”,
 “CanUseSystemOffDates”: true
}

Retrieve all ServiceLevelTerms

Description: This API method retrieves a collection of all currently-defined ServiceLevelTerms from the Issuetrak data store.

When retrieving a ServiceLevelTerm using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the ServiceLevelTermName returned via the API method represents the ServiceLevelTermName as stored within the Issuetrak database. Thus, when retrieving a Cause created through the Issuetrak web interface where HTML encoding of the ServiceLevelTermName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadServiceLevelTermDTO instance.

{
 “IsPageIndexZeroBased”: false,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    {
     “Key”: "",
     “Value”: ""
    }
   ],
   “Metadata”: [
    {
     “Key”: "",
     “Value”: ""
    }
   ],
   “ServiceLevelTermID”: 0,
   “ServiceLevelID”: 0,
   “SeverityID”: 0,
   “ResponseTime”: 0,
   “ResolutionTime”: 0,
   “CoverageStartDay”: 0,
   “CoverageEndDay”: 0,
   “Comment”: "",
   “CanUseSystemOffDates”: false
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent ServiceLevelTerm: 404

Response DTO Property Notes:

• The IsPageIndexZeroBased property value is always true. This property is included for use in future API versions.
• The PageIndex property value is always 0. This property is included for use in future API versions.
• The CountForPage property value is always the same as TotalCount. This property is included for use in future API versions.
• The PageSize property value is always the maximum value for a signed, 32-bit integer. This property is included for use in future API versions.
• The TotalCount property value is the number of records returned in the collection.
• The Collection property is an array containing the ReadServiceLevelTermDTO objects returned.
• The ExtensionData property is not implemented in v1 of the API.
• The CoverageStartDay property is an Int32 value in the range 1 to 7 with 1 representing Monday, 2 representing Tuesday, …, 7 representing Sunday.
• The CoverageEndDay property is an Int32 value in the range 1 to 7 with 1 representing Monday, 2 representing Tuesday, …, 7 representing Sunday.

Sample Request URL: ~/api/v1/servicelevelterms/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “v1”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2015-02-09T15:44:45.3778772Z”
    }
   ],
   “ServiceLevelTermID”: 1,  
   “ServiceLevelID”: 1,
   “SeverityID”: 3,
   “ResponseTime”: 10,
   “ResolutionTime”: 30,
   “CoverageStartTime”: “1899-12-30T00:00:00”,
   “CoverageEndTime”: “1899-12-30T23:59:00”,
   “CoverageStartDay”: 1,
   “CoverageEndDay”: 7,
   “Comment”: “Test Comment”,
   “CanUseSystemOffDates”: true
  }
 ]
}

Summary

Operation Name: Retrieve a Substatus by Substatus ID
Relative API Request Path: ~/api/v1/substatuses/{substatusID}
HTTP Verb: GET
Description: Retrieve a single Substatus by Substatus ID.

Operation Name: Retrieve all Substatuses
Relative API Request Path: ~/api/v1/substatuses
HTTP Verb: GET
Description: Retrieve a collection of currently defined Substatuses.

Retrieve a Substatus by Substatus ID

This API method retrieves a Substatus from the Issuetrak data store for a specified Substatus ID. The substatusID parameter must correspond to an existing Substatus. If there is no such Substatus ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a Substatus using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the SubStatusName returned via the API method represents the SubstatusName as stored within the Issuetrak database. Thus, when retrieving a Substatus created through the Issuetrak web interface where HTML encoding of the SubstatusName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadSubstatusDTO instance.

ReadSubStatusDTO
{
 ExtensionData (array[KeyValuePair[String,Object]]),
 Metadata (array[KeyValuePair[String,Object]]),
 SubStatusID (integer),
 SubStatusName (string),
 DisplayOrder (number)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid Substatus ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Substatus: 404
• Invalid Substatus ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/substatuses/13

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “v1”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2014-12-22T16:03:33.1153793Z”
  }
 ],
 “SubStatusID”: 13,
 “SubStatusName”: “Pending Assignment”,
 “DisplayOrder”: 1
}

Retrieve all Substatuses

This API method retrieves a collection of all currently-defined Substatus entries from the Issuetrak data store.

When retrieving a Substatus using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the SubstatusName returned via the API method represents the SubstatusName as stored within the Issuetrak database. Thus, when retrieving a Substatus created through the Issuetrak web interface where HTML encoding of the SubstatusName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadSubstatusDTO instance.

{
 “IsPageIndexZeroBased”: false,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    “KeyValuePair[String,Object]”
   ],
   “Metadata”: [
    “KeyValuePair[String,Object]”
   ],
   “SubStatusID”: 0,
   “SubStatusName”: "",
   “DisplayOrder”: 0
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent Substatus: 404

Sample Request URL: ~/api/v1/substatuses/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 11,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “v1”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2014-12-22T16:06:29.8010461Z”
    }
   ],
   “SubStatusID”: 8,
   “SubStatusName”: “Complete – Pending Second Review”,
   “DisplayOrder”: 9
  }
 ]
}

Summary

Operation Name: Retrieve a TimeZone by TimeZone ID
Relative API Request Path: ~/api/v1/timezones/{timeZoneID}
HTTP Verb: GET
Description: Retrieve a single TimeZone by TimeZone ID.

Operation Name: Retrieve all TimeZones
Relative API Request Path: ~/api/v1/timezones
HTTP Verb: GET
Description: Retrieve a collection of currently defined TimeZones.

Retrieve a TimeZone by TimeZone ID

This API method retrieves a TimeZone from the Issuetrak data store for a specified TimeZone ID. The TimeZoneID parameter must correspond to an existing TimeZone. If there is no such TimeZone ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a TimeZone using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the TimeZoneName returned via the API method represents the TimeZoneName as stored within the Issuetrak database. Thus, when retrieving a TimeZone created through the Issuetrak web interface where HTML encoding of the TimeZoneName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadTimeZoneDTO instance.

ReadTimeZoneDTO
{
 “ExtensionData”: [
  {
   “Key”: “string”,
   “Value”: {}
  }
 ],
 “Metadata”: [
  “CustomKeyValuePairDataElement”
 ],
 “TimeZoneID”: 0,
 “TimeZone”: “string”,
 “Display”: “string”,
 “DaylightDisplay”: “string”,
 “DaylightAbbreviation”: “string”,
 “StandardDisplay”: “string”,
 “StandardAbbreviation”: “string”,
 “Bias”: 0,
 “DaylightBias”: 0,
 “StandardBias”: 0,
 “DaylightYear”: 0,
 “DaylightMonth”: 0,
 “DaylightDOWCount”: 0,
 “DaylightDayOfWeek”: 0,
 “DaylightHour”: 0,
 “DaylightMinute”: 0,
 “DaylightSecond”: 0,
 “DaylightMillisecond”: 0,
 “StandardYear”: 0,
 “StandardMonth”: 0,
 “StandardDOWCount”: 0,
 “StandardDayOfWeek”: 0,
 “StandardHour”: 0,
 “StandardMinute”: 0,
 “StandardSecond”: 0,
 “StandardMillisecond”: 0
}
CustomKeyValuePairDataElement
{
 Key (string),
 Value (string)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid TimeZone ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent Cause: 404
• Invalid TimeZone ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/timezones/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “v1”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2015-03-12T15:22:49.0895913Z”
  }
 ],
 “TimeZoneID”: 1,
 “TimeZone”: “Afghanistan Standard Time”,
 “Display”: “(GMT+04:30) Kabul”,
 “DaylightDisplay”: “Afghanistan Daylight Time”,
 “DaylightAbbreviation”: null,
 “StandardDisplay”: “Afghanistan Standard Time”,
 “StandardAbbreviation”: null,
 “Bias”: -270,
 “DaylightBias”: -60,
 “StandardBias”: 0,
 “DaylightYear”: 0,
 “DaylightMonth”: 0,
 “DaylightDOWCount”: 0,
 “DaylightDayOfWeek”: 0,
 “DaylightHour”: 0,
 “DaylightMinute”: 0,
 “DaylightSecond”: 0,
 “DaylightMillisecond”: 0,
 “StandardYear”: 0,
 “StandardMonth”: 0,
 “StandardDOWCount”: 0,
 “StandardDayOfWeek”: 0,
 “StandardHour”: 0,
 “StandardMinute”: 0,
 “StandardSecond”: 0,
 “StandardMillisecond”: 0
}

Retrieve all TimeZones

This API method retrieves a collection of all currently-defined TimeZones from the Issuetrak data store.

When retrieving a TimeZone using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the TimeZoneName returned via the API method represents the TimeZoneName as stored within the Issuetrak database. Thus, when retrieving a Cause created through the Issuetrak web interface where HTML encoding of the TimeZoneName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadTimeZoneDTO instance.

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    {
     “Key”: “string”,
     “Value”: {}
    }
   ],
   “Metadata”: [
    “CustomKeyValuePairDataElement”
   ],
   “TimeZoneID”: 0,
   “TimeZone”: “string”,
   “Display”: “string”,
   “DaylightDisplay”: “string”,
   “DaylightAbbreviation”: “string”,
   “StandardDisplay”: “string”,
   “StandardAbbreviation”: “string”,
   “Bias”: 0,
   “DaylightBias”: 0,
   “StandardBias”: 0,
   “DaylightYear”: 0,
   “DaylightMonth”: 0,
   “DaylightDOWCount”: 0,
   “DaylightDayOfWeek”: 0,
   “DaylightHour”: 0,
   “DaylightMinute”: 0,
   “DaylightSecond”: 0,
   “DaylightMillisecond”: 0,
   “StandardYear”: 0,
   “StandardMonth”: 0,
   “StandardDOWCount”: 0,
   “StandardDayOfWeek”: 0,
   “StandardHour”: 0,
   “StandardMinute”: 0,
   “StandardSecond”: 0,
   “StandardMillisecond”: 0
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent TimeZone: 404

Sample Request URL: ~/api/v1/timezones/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 1,
 “PageSize”: 2147483647,
 “TotalCount”: 1,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “v1”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2015-03-12T15:20:31.6548492Z”
    }
   ],
   “TimeZoneID”: 1,
   “TimeZone”: “Afghanistan Standard Time”,
   “Display”: “(GMT+04:30) Kabul”,
   “DaylightDisplay”: “Afghanistan Daylight Time”,
   “DaylightAbbreviation”: null,
   “StandardDisplay”: “Afghanistan Standard Time”,
   “StandardAbbreviation”: null,
   “Bias”: -270,
   “DaylightBias”: -60,
   “StandardBias”: 0,
   “DaylightYear”: 0,
   “DaylightMonth”: 0,
   “DaylightDOWCount”: 0,
   “DaylightDayOfWeek”: 0,
   “DaylightHour”: 0,
   “DaylightMinute”: 0,
   “DaylightSecond”: 0,
   “DaylightMillisecond”: 0,
   “StandardYear”: 0,
   “StandardMonth”: 0,
   “StandardDOWCount”: 0,
   “StandardDayOfWeek”: 0,
   “StandardHour”: 0,
   “StandardMinute”: 0,
   “StandardSecond”: 0,
   “StandardMillisecond”: 0
  }
 ]
}

Summary

Operation Name: Retrieve a User by User ID
Relative API Request Path: ~/api/v1/users/{userID}/{includeUserPhoto}
HTTP Verb: GET
Description: Retrieve a single User by User ID.

Operation Name: Retrieve all Users
Relative API Request Path: ~/api/v1/users/{ includeUserPhotos}
HTTP Verb: GET
Description: Retrieve a collection of currently defined Users.

Operation Name: Create a User
Relative API Request Path: ~/api/v1/users
HTTP Verb: POST
Description: Create a User

Operation Name: Update a User
Relative API Request Path: ~/api/v1/users
HTTP Verb: PUT
Description: Update a User

Operation Name: Update a User Password
Relative API Request Path: ~/api/v1/users/password
HTTP Verb: PUT
Description: Update a User Password

Operation Name: Inactivate a User
Relative API Request Path: ~/api/v1/users/inactivate
HTTP Verb: PUT
Description: Inactivate a User

Retrieve a User by User ID

This API method retrieves a User from the Issuetrak data store for a specified User ID. The userID parameter must correspond to an existing User. If there is no such User ID, an error message will be returned with an HTTP response status code of 404.

The IncludeUserPhoto is a true or false parameter is a Boolean indicating whether or the binary content for any existing user photo image file should be retrieved and included in the response. If the IncludeUserPhoto parameter is true and if a user photo image file exists for the specified user, a base-64 encoded byte array representing the photo image file will be included in the UserPhotoBytes property of the response. If the IncludeUserPhoto parameter is false or if the user photo image file is not defined, the UserPhotoBytes property will be null.

When retrieving an User using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the UserName returned via the API method represents the UserName as stored within the Issuetrak database. Thus, when retrieving a User created through the Issuetrak web interface where HTML encoding of the UserName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadUserDTO instance.

ReadUserDTO
{
 ExtensionData (Array[CustomKeyValuePairDataElement]),
Metadata (Array[CustomKeyValuePairDataElement]),
UserID (string),
UserNumber (integer),
UserTypeID (integer),
FirstName (string),
LastName (string),
DisplayName (string),
Address1 (string),
Address2 (string),
City (string),
State (string),
ZipCode (string),
Country (string),
EmailAddress (string),
Pager (string),
Phone (string),
DepartmentID (integer),
OrganizationID (integer),
LocationID (string),
IsActive (boolean),
ShouldShowDebug (boolean),
IsSysAdmin (boolean),
CreatedBy (string),
CreatedDate (string): ISO 8601 string,
ModifiedBy (string),
ModifiedDate (string): ISO 8601 string,
LastLoginDate (string): ISO 8601 string,
CannotLogin (boolean),
HasNoAuthentication (boolean),
LastPasswordChange (string): ISO 8601 string,
LoginAttempts (integer),
UserDefined1ID (integer),
UserDefined1 (string),
UserDefined2ID (integer),
UserDefined2 (string),
UserDefined3ID (integer),
UserDefined3 (string),
UserDefinedDate (string): ISO 8601 string,
TimeZoneID (integer),
DoesTimeZoneUseDaylightSavings (boolean),
HomePageID (integer)integerMin. Value:1Max. Value:2147483647,
DashboardReload (integer),
ShouldDashboardShowTimer (boolean),
DashboardDefaultClass (integer),
UserPhotoBytes (string): Base64 string,
DashboardDefaultMonths (integer),
RedirectTo (string),
ListFormat (string)
}CustomKeyValuePairDataElement {
Key (string, optional),
Value (object, optional)
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid User ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent User: 404

Sample Request URL: ~/api/v1/users/11/false

{
  "ExtensionData": [
    {
      "Key": "string",
      "Value": {}
    }
  ],
  "Metadata": [
    {
      "Key": "string",
      "Value": {}
    }
  ],
  "UserID": "string",
  "UserNumber": 0,
  "UserTypeID": 0,
  "FirstName": "string",
  "LastName": "string",
  "DisplayName": "string",
  "Address1": "string",
  "Address2": "string",
  "City": "string",
  "State": "string",
  "ZipCode": "string",
  "Country": "string",
  "EmailAddress": "string",
  "Pager": "string",
  "Phone": "string",
  "DepartmentID": 0,
  "OrganizationID": 0,
  "LocationID": "string",
  "IsActive": true,
  "ShouldShowDebug": true,
  "IsSysAdmin": true,
  "CreatedBy": "string",
  "CreatedDate": "string",
  "ModifiedBy": "string",
  "ModifiedDate": "string",
  "LastLoginDate": "string",
  "CannotLogin": true,
  "HasNoAuthentication": true,
  "LastPasswordChange": "string",
  "LoginAttempts": 0,
  "UserDefined1ID": 0,
  "UserDefined1": "string",
  "UserDefined2ID": 0,
  "UserDefined2": "string",
  "UserDefined3ID": 0,
  "UserDefined3": "string",
  "UserDefinedDate": "string",
  "TimeZoneID": 0,
  "DoesTimeZoneUseDaylightSavings": true,
  "HomePageID": 0,
  "DashboardReload": 0,
  "ShouldDashboardShowTimer": true,
  "DashboardDefaultClass": 0,
  "UserPhotoBytes": "string",
  "DashboardDefaultMonths": 0,
  "RedirectTo": "string",
  "ListFormat": "string"
}

Retrieve All Users

This API method retrieves a collection of all currently-defined Users from the Issuetrak data store.

No UserPhotoBytes content is retrieved during this API method. All of the ReadUserDTO instances will have the UserPhotoBytes content property set to null.

When retrieving an User using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the UserName returned via the API method represents the UserName as stored within the Issuetrak database. Thus, when retrieving a User created through the Issuetrak web interface where HTML encoding of the UserName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadUserDTO instance.

 QueryResultsContainer[ReadUserDTO] 
{
IsPageIndexZeroBased (boolean, optional),
PageIndex (integer, optional),
CountForPage (integer, optional),
PageSize (integer, optional),
TotalCount (integer, optional),
Collection (Array[ReadUserDTO], optional)
}ReadUserDTO {
ExtensionData (Array[CustomKeyValuePairDataElement]),
Metadata (Array[CustomKeyValuePairDataElement]),
UserID (string),
UserNumber (integer),
UserTypeID (integer),
FirstName (string),
LastName (string),
DisplayName (string),
Address1 (string),
Address2 (string),
City (string),
State (string),
ZipCode (string),
Country (string),
EmailAddress (string),
Pager (string),
Phone (string),
DepartmentID (integer),
OrganizationID (integer),
LocationID (string),
IsActive (boolean),
ShouldShowDebug (boolean),
IsSysAdmin (boolean),
CreatedBy (string),
CreatedDate (string): ISO 8601 string,
ModifiedBy (string),
ModifiedDate (string): ISO 8601 string,
LastLoginDate (string):ISO 8601 string,
CannotLogin (boolean),
HasNoAuthentication (boolean),
LastPasswordChange (string): ISO 8601 string,
LoginAttempts (integer),
UserDefined1ID (integer),
UserDefined1 (string),
UserDefined2ID (integer),
UserDefined2 (string),
UserDefined3ID (integer),
UserDefined3 (string),
UserDefinedDate (string): ISO 8601 string,
TimeZoneID (integer),
DoesTimeZoneUseDaylightSavings (boolean),
HomePageID (integer)integerMin. Value:1Max. Value:2147483647,
DashboardReload (integer),
ShouldDashboardShowTimer (boolean),
DashboardDefaultClass (integer),
UserPhotoBytes (string): Base64 string ,
DashboardDefaultMonths (integer),
RedirectTo (string),
ListFormat (string)
}CustomKeyValuePairDataElement {
Key (string, optional),
Value (object, optional)
} 

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent User: 404

Sample Request URL: ~/api/v1/users/

{
  "IsPageIndexZeroBased": true,
  "PageIndex": 0,
  "CountForPage": 0,
  "PageSize": 0,
  "TotalCount": 0,
  "Collection": [
    {
      "ExtensionData": [
        {
          "Key": "string",
          "Value": {}
        }
      ],
      "Metadata": [
        {
          "Key": "string",
          "Value": {}
        }
      ],
      "UserID": "string",
      "UserNumber": 0,
      "UserTypeID": 0,
      "FirstName": "string",
      "LastName": "string",
      "DisplayName": "string",
      "Address1": "string",
      "Address2": "string",
      "City": "string",
      "State": "string",
      "ZipCode": "string",
      "Country": "string",
      "EmailAddress": "string",
      "Pager": "string",
      "Phone": "string",
      "DepartmentID": 0,
      "OrganizationID": 0,
      "LocationID": "string",
      "IsActive": true,
      "ShouldShowDebug": true,
      "IsSysAdmin": true,
      "CreatedBy": "string",
      "CreatedDate": "string",
      "ModifiedBy": "string",
      "ModifiedDate": "string",
      "LastLoginDate": "string",
      "CannotLogin": true,
      "HasNoAuthentication": true,
      "LastPasswordChange": "string",
      "LoginAttempts": 0,
      "UserDefined1ID": 0,
      "UserDefined1": "string",
      "UserDefined2ID": 0,
      "UserDefined2": "string",
      "UserDefined3ID": 0,
      "UserDefined3": "string",
      "UserDefinedDate": "string",
      "TimeZoneID": 0,
      "DoesTimeZoneUseDaylightSavings": true,
      "HomePageID": 0,
      "DashboardReload": 0,
      "ShouldDashboardShowTimer": true,
      "DashboardDefaultClass": 0,
      "UserPhotoBytes": "string",
      "DashboardDefaultMonths": 0,
      "RedirectTo": "string",
      "ListFormat": "string"
    }
  ]
}

Create a User

This API method creates a new User associated with a specific UserID within the Issuetrak data store. The CreateUserDTO object conveys the properties of the new User. Because UserID values must be unique, the specified UserID value must not currently exist. If the UserID currently exists, an error message will be returned with a 400 HTTP status code.

The response code on success will be 201 (Created), and the response body will represent the text value representing the ID of the newly-created User.

When creating a User using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed.

CreateUserDTO
{
UserID (string),
Password (string),
UserTypeID (integer),
FirstName (string),
LastName (string),
DisplayName (string),
Address1 (string),
Address2 (string),
City (string),
State (string),
ZipCode (string),
Country (string),
EmailAddress (string),
Pager (string),
Phone (string),
DepartmentID (integer),
OrganizationID (integer),
LocationID (string),
IsActive (boolean),
ShouldShowDebug (boolean),
IsSysAdmin (boolean),
CreatedBy (string),
CreatedDate (string): ISO 8601 string,
ModifiedBy (string),
ModifiedDate (string): ISO 8601 string,
LastLoginDate (string): ISO 8601 string,
CannotLogin (boolean),
HasNoAuthentication (boolean),
LastPasswordChange (string): ISO 8601 string,
LoginAttempts (integer),
UserDefined1ID (integer),
UserDefined1 (string),
UserDefined2ID (integer),
UserDefined2 (string),
UserDefined3ID (integer),
UserDefined3 (string),
UserDefinedDate (string): ISO 8601 string,
TimeZoneID (integer),
DoesTimeZoneUseDaylightSavings (boolean),
HomePageID (integer)integerMin. Value:1Max. Value:2147483647,
DashboardReload (integer),
ShouldDashboardShowTimer (boolean),
DashboardDefaultClass (integer),
UserPhotoBytes (string): Base64 string,
DashboardDefaultMonths (integer),
RedirectTo (string),
ListFormat (string)
} 

Request HTTP Verb: POST

Response Status Codes:

• Success: 201
• Invalid User Properties: 400 (Bad Request, e.g., a negative integer is supplied)
• Invalid User DTO: 422 (Unprocessable Entity, e.g., an invalid value is supplied)

Sample Request URL: ~/api/v1/users/

{
  "UserID": "string",
  "Password": "string",
  "UserTypeID": 0,
  "FirstName": "string",
  "LastName": "string",
  "DisplayName": "string",
  "Address1": "string",
  "Address2": "string",
  "City": "string",
  "State": "string",
  "ZipCode": "string",
  "Country": "string",
  "EmailAddress": "string",
  "Pager": "string",
  "Phone": "string",
  "DepartmentID": 0,
  "OrganizationID": 0,
  "LocationID": "string",
  "IsActive": true,
  "ShouldShowDebug": true,
  "IsSysAdmin": true,
  "CreatedBy": "string",
  "CreatedDate": "string",
  "ModifiedBy": "string",
  "ModifiedDate": "string",
  "LastLoginDate": "string",
  "CannotLogin": true,
  "HasNoAuthentication": true,
  "LastPasswordChange": "string",
  "LoginAttempts": 0,
  "UserDefined1ID": 0,
  "UserDefined1": "string",
  "UserDefined2ID": 0,
  "UserDefined2": "string",
  "UserDefined3ID": 0,
  "UserDefined3": "string",
  "UserDefinedDate": "string",
  "TimeZoneID": 0,
  "DoesTimeZoneUseDaylightSavings": true,
  "HomePageID": 0,
  "DashboardReload": 0,
  "ShouldDashboardShowTimer": true,
  "DashboardDefaultClass": 0,
  "UserPhotoBytes": "string",
  "DashboardDefaultMonths": 0,
  "RedirectTo": "string",
  "ListFormat": "string"
}

Sample Response HTTP Status Code: 201

Sample Response Body: TestUser1 (represents the newly-created User ID)

Update a User

This API method updates an existing User associated with a specific UserNumber within the Issuetrak data store. The UpdateUserDTO object conveys the properties of the existing User. Because UserID values must be unique, the specified UserID value must not currently exist for a user with a different UserNumber. If the UserID currently exists, an error message will be returned with a 400 HTTP status code. 

Setting a user's organization via the API will result in the requested organization becoming the primary organization for the user.  If the user previously had multiple organization memberships, then these will be retained and the user will continue to have membership in their previous primary organization (but without it being their primary organization). 

The User Password property cannot be updated with this API method. Please use the dedicated API controller method for password updates.

The response code on success will be 200 (OK), and the response body will represent the text value representing the ID of the edited User.

When creating a User using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed.

UpdateUserDTO
{
UserID (string),
UserNumber (integer),
UserTypeID (integer),
FirstName (string),
LastName (string),
DisplayName (string),
Address1 (string),
Address2 (string),
City (string),
State (string),
ZipCode (string),
Country (string),
EmailAddress (string),
Pager (string),
Phone (string),
DepartmentID (integer),
OrganizationID (integer),
LocationID (string),
IsActive (boolean),
ShouldShowDebug (boolean),
IsSysAdmin (boolean),
CreatedBy (string),
CreatedDate (string): ISO 8601 string,
ModifiedBy (string),
ModifiedDate (string): ISO 8601 string,
LastLoginDate (string): ISO 8601 string,
CannotLogin (boolean),
HasNoAuthentication (boolean),
LastPasswordChange (string): ISO 8601 string,
LoginAttempts (integer),
UserDefined1ID (integer),
UserDefined1 (string),
UserDefined2ID (integer),
UserDefined2 (string),
UserDefined3ID (integer),
UserDefined3 (string),
UserDefinedDate (string): ISO 8601 string,
TimeZoneID (integer),
DoesTimeZoneUseDaylightSavings (boolean),
HomePageID (integer)integerMin. Value:1Max. Value:2147483647,
DashboardReload (integer),
ShouldDashboardShowTimer (boolean),
DashboardDefaultClass (integer),
UserPhotoBytes (string): Base64 string,
DashboardDefaultMonths (integer),
RedirectTo (string),
ListFormat (string)
} 

Request HTTP Verb: PUT

Response Status Codes:

• Success: 200
• Invalid User Properties: 400 (Bad Request, e.g., a negative integer is supplied)
• Invalid User DTO: 422 (Unprocessable Entity, e.g., an invalid value is supplied)

Sample Request URL: ~/api/v1/users/

{
  "UserID": "string",
  "UserNumber": 0,
  "UserTypeID": 0,
  "FirstName": "string",
  "LastName": "string",
  "DisplayName": "string",
  "Address1": "string",
  "Address2": "string",
  "City": "string",
  "State": "string",
  "ZipCode": "string",
  "Country": "string",
  "EmailAddress": "string",
  "Pager": "string",
  "Phone": "string",
  "DepartmentID": 0,
  "OrganizationID": 0,
  "LocationID": "string",
  "IsActive": true,
  "ShouldShowDebug": true,
  "IsSysAdmin": true,
  "CreatedBy": "string",
  "CreatedDate": "string",
  "ModifiedBy": "string",
  "ModifiedDate": "string",
  "LastLoginDate": "string",
  "CannotLogin": true,
  "HasNoAuthentication": true,
  "LastPasswordChange": "string",
  "LoginAttempts": 0,
  "UserDefined1ID": 0,
  "UserDefined1": "string",
  "UserDefined2ID": 0,
  "UserDefined2": "string",
  "UserDefined3ID": 0,
  "UserDefined3": "string",
  "UserDefinedDate": "string",
  "TimeZoneID": 0,
  "DoesTimeZoneUseDaylightSavings": true,
  "HomePageID": 0,
  "DashboardReload": 0,
  "ShouldDashboardShowTimer": true,
  "DashboardDefaultClass": 0,
  "UserPhotoBytes": "string",
  "DashboardDefaultMonths": 0,
  "RedirectTo": "string",
  "ListFormat": "string"
}

Sample Response HTTP Status Code: 200

Sample Response Body: TestUser1 (represents the edited User ID)

Update a User Password

This API method updates the password for an existing User associated with a specific UserID within the Issuetrak data store. The UpdateUserPasswordDTO object conveys the new password. Because UserID values must be unique, the specified UserID value must currently exist. If the UserID currently exists, an error message will be returned with a 400 HTTP status code.

The response code on success will be 200 (OK), and the response body will represent the text value representing the ID of the edited User.

When creating a User using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed.

UpdateUserPasswordDTO
{
 UserID (string),
 Password (string)
}

Request HTTP Verb: PUT

Response Status Codes:

• Success: 200
• Invalid User Properties: 400 (Bad Request, e.g., a negative integer is supplied)
• Invalid User DTO: 422 (Unprocessable Entity, e.g., an invalid value is supplied)

Sample Request URL: ~/api/v1/users/password/

{
 “UserID”: “TestUser1”,
 “Password”: “New.Password”
}

Sample Response HTTP Status Code: 200

Sample Response Body: TestUser1 (represents the edited User ID)

Inactivate a User

This API method updates an existing User associated with a specific UserID within the Issuetrak data store. The InactivateUserDTO object conveys the UserID of the existing User to inactivate. Because UserID values must be unique, the specified UserID value must exist. If the UserID does not currently exist, an error message will be returned with a 400 HTTP status code.

The response code on success will be 200 (OK), and the response body will represent the text value representing the ID of the inactivated User.

When inactivating a User using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed.

{
 UserID (string),
}

Request HTTP Verb: PUT

Response Status Codes:

• Success: 200
• Invalid User Properties: 400 (Bad Request, e.g., a non-existent UserID is specified)
• Invalid User DTO: 422 (Unprocessable Entity, e.g., an invalid value is supplied)

Sample Request URL: ~/api/v1/users/inactivate

{
 “UserID”: “InactiveUser”,
}

Sample Response HTTP Status Code: 200

Sample Response Body: InactiveUser (represents the inactivated User ID)

Summary

Operation Name: Retrieve a User Type by UserTypeID
Relative API Request Path: ~/api/v1/usertypes/{usertypeID}
HTTP Verb: GET
Description: Retrieve a single User Type by User Type ID.

Operation Name: Retrieve all User Types
Relative API Request Path: ~/api/v1/usertypes
HTTP Verb: GET
Description: Retrieve a collection of currently defined User Types.

Retrieve a User Type by UserTypeID

This API method retrieves a User Type from the Issuetrak data store for a specified User Type ID. The userTypeID parameter must correspond to an existing User Type. If there is no such User Type ID, an error message will be returned with an HTTP response status code of 404.

When retrieving an User Type using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the UserTypeName returned via the API method represents the UserTypeName as stored within the Issuetrak database. Thus, when retrieving a User Type created through the Issuetrak web interface where HTML encoding of the UserTypeName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadUserTypeDTO instance.

ReadUserTypeDTO
{
 ExtensionData (array[KeyValuePair[String,Object]]),
 Metadata (array[KeyValuePair[String,Object]]),
 “UserTypeID”: 0,
 “UserTypeName”: ”"
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid User Type ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent User Type: 404
• Invalid User Type ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/usertypes/1

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “10.2”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2015-08-10T17:34:42.1369273Z”
  }
 ],
 “UserTypeID”: 1,
 “UserTypeName”: “Agent”
}

Retrieve all User Types

This API method retrieves a collection of all currently-defined User Types from the Issuetrak data store.

When retrieving an User Type using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the UserTypeName returned via the API method represents the UserTypeName as stored within the Issuetrak database. Thus, when retrieving a User Type created through the Issuetrak web interface where HTML encoding of the UserTypeName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadUserTypeDTO instance.

{
 “IsPageIndexZeroBased”: false,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    “KeyValuePair[String,Object]”
   ],
   “Metadata”: [
    “KeyValuePair[String,Object]”
   ],
   “UserTypeID”: 0,
   “UserTypeName”: ""
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent UserType: 404

Sample Request URL: ~/api/v1/usertypes/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 2,
 “PageSize”: 2147483647,
 “TotalCount”: 2,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “10.2”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2015-08-10T17:37:43.2050323Z”
    }
   ],
   “UserTypeID”: 1,
   “UserTypeName”: “Agent”
  },
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “10.2”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2015-08-10T17:37:43.2050323Z”
    }
   ],
   “UserTypeID”: 2,
   “UserTypeName”: “EndUser”
  }
 ]
}

Summary

Operation Name: Retrieve a UserDefined FieldType by ID
Relative API Request Path: ~/api/v1/userdefinedfieldtypes/{userDefinedFieldTypeID}
HTTP Verb: GET
Description: Retrieve a single UserDefinedFieldType by UserDefinedFieldType ID.

Operation Name: Retrieve all UserDefinedFieldTypes
Relative API Request Path: ~/api/v1/userdefinedfieldtypes
HTTP Verb: GET
Description: Retrieve a collection of currently defined UserDefinedFieldTypes.

Retrieve a UserDefined FieldType by ID

Description: This API method retrieves a UserDefinedFieldType from the Issuetrak data store for a specified UserDefinedFieldType ID. The “UserDefinedFieldTypeID” parameter must correspond to an existing UserDefinedFieldType. If there is no such UserDefinedFieldType ID, an error message will be returned with an HTTP response status code of 404.

When retrieving a UserDefinedFieldType using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the DisplayName returned via the API method represents the DisplayName as stored within the Issuetrak database. Thus, when retrieving a UserDefinedFieldType created through the Issuetrak web interface where HTML encoding of the DisplayName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized ReadUserDefinedFieldTypeDTO instance.

ReadUserDefinedFieldTypeDTO
{
 “ExtensionData”: [
  {
   “Key”: “string”,
   “Value”: {}
  }
 ],
 “Metadata”: [
  {
   “Key”: “string”,
   “Value”: {}
  }
 ],
 “UserDefinedFieldID”: 0,
 “UserDefinedKeyID”: 0,
 “DisplayName”: “string”,
 “IsPrivate”: true,
 “TextDisplayWidth”: 0,
 “ReferenceNumber”: 0
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Invalid UserDefinedFieldType ID: 400 (Bad Request, e.g., a negative integer is supplied)
• Non-existent UserDefinedFieldType: 404
• Invalid UserDefinedFieldType ID: 422 (Unprocessable Entity, e.g., a non-numeric value is supplied)

Sample Request URL: ~/api/v1/userdefinedfieldtypes/4

{
 “ExtensionData”: [],
 “Metadata”: [
  {
   “Key”: “APIVersion”,
   “Value”: “v1”
  },
  {
   “Key”: “QueryDate”,
   “Value”: “2014-12-24T16:15:35.5023536Z”
  }
 ],
 “UserDefinedFieldID”: 4,
 “UserDefinedKeyID”: 2,
 “DisplayName”: “Large Text 1”,
 “IsPrivate”: false,
 “TextDisplayWidth”: 0,
 “ReferenceNumber”: 1
}

Retrieve all UserDefinedFieldTypes

This API method retrieves a collection of all currently-defined UserDefinedFieldType entities from the Issuetrak data store.

When retrieving a UserDefinedFieldType using the API, no special character decoding (e.g., HTML decoding &lt; as < or &gt; as >) is performed. Therefore, please note that the DisplayName returned via the API method represents the DisplayName as stored within the Issuetrak database. Thus, when retrieving a UserDefinedFieldType created through the Issuetrak web interface where HTML encoding of the DisplayName is performed, the API consumer may desire to perform additional client-side decoding.

A successful response will include an HTTP status code of 200 (OK) and a response body containing a serialized collection of ReadUserDefinedFieldTypeDTO instance.

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 0,
 “PageSize”: 0,
 “TotalCount”: 0,
 “Collection”: [
  {
   “ExtensionData”: [
    {
     “Key”: “string”,
     “Value”: {}
    }
   ],
   “Metadata”: [
    {
     “Key”: “string”,
     “Value”: {}
    }
   ],
   “UserDefinedFieldID”: 0,
   “UserDefinedKeyID”: 0,
   “DisplayName”: “string”,
   “IsPrivate”: true,
   “TextDisplayWidth”: 0,
   “ReferenceNumber”: 0
  }
 ]
}

Request HTTP Verb: GET

Response Status Codes:

• Success: 200
• Non-existent UserDefinedFieldType: 404

Sample Request URL: ~/api/v1/userdefinedfieldtypes/

{
 “IsPageIndexZeroBased”: true,
 “PageIndex”: 0,
 “CountForPage”: 10,
 “PageSize”: 2147483647,
 “TotalCount”: 10,
 “Collection”: [
  {
   “ExtensionData”: [],
   “Metadata”: [
    {
     “Key”: “APIVersion”,
     “Value”: “v1”
    },
    {
     “Key”: “QueryDate”,
     “Value”: “2014-12-24T16:16:12.6629828Z”
    }
   ],
   “UserDefinedFieldID”: 1,
   “UserDefinedKeyID”: 1,
   “DisplayName”: “Primary Sec ID”,
   “IsPrivate”: false,
   “TextDisplayWidth”: 5,
   “ReferenceNumber”: 1
  }
 ]
}