mirror of
https://github.com/hanzo-go/sdk.git
synced 2026-11-20 20:13:42 +00:00
3539 lines
123 KiB
Go
3539 lines
123 KiB
Go
/*
|
|
Hanzo Cloud API
|
|
|
|
The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
|
|
|
|
API version: v1
|
|
*/
|
|
|
|
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
|
|
|
|
package hanzoai
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
)
|
|
|
|
// PatrolAPIService PatrolAPI service
|
|
type PatrolAPIService service
|
|
|
|
type PatrolAPIGetPatrolCameraRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
site *string
|
|
}
|
|
|
|
// Site narrows the list to one site by document name. Empty lists every camera.
|
|
func (r PatrolAPIGetPatrolCameraRequest) Site(site string) PatrolAPIGetPatrolCameraRequest {
|
|
r.site = &site
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolCameraRequest) Execute() (*PatrolPatrolCameraList, *http.Response, error) {
|
|
return r.ApiService.GetPatrolCameraExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolCamera Lists the cameras a caller may OPEN.
|
|
|
|
Lists the cameras a caller may OPEN. A row somebody can never reach is
|
|
a catalogue of a customer's premises and nothing else, so the admission the
|
|
stream enforces is asked here too rather than left to differ from it.
|
|
|
|
The stream credential is not part of a camera row — it is a KMS path the
|
|
document store never holds — so what comes back says where a camera is and
|
|
never how to reach it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolCameraRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolCamera(ctx context.Context) PatrolAPIGetPatrolCameraRequest {
|
|
return PatrolAPIGetPatrolCameraRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolCameraList
|
|
func (a *PatrolAPIService) GetPatrolCameraExecute(r PatrolAPIGetPatrolCameraRequest) (*PatrolPatrolCameraList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolCameraList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolCamera")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/camera"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.site != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "site", r.site, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolCameraByNameStreamRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolCameraByNameStreamRequest) Execute() (*PatrolPatrolStreamOut, *http.Response, error) {
|
|
return r.ApiService.GetPatrolCameraByNameStreamExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolCameraByNameStream Mints a short-lived way in to one camera.
|
|
|
|
Mints a short-lived way in to one camera.
|
|
|
|
The credential is kept in KMS, at the one place a camera's credential is kept
|
|
— the org's own patrol namespace, named for the camera — and what comes back
|
|
is minted from it rather than being it: the camera's address with the user and
|
|
password removed, bounded by an expiry, and signed so that whatever opens the
|
|
camera can tell a live ticket from a made-up one. The caller receives
|
|
something that opens one camera for five minutes and says nothing about how.
|
|
|
|
A camera whose row points anywhere but its own place, and one with no
|
|
credential registered, is 404.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the camera's document name, from the path.
|
|
@return PatrolAPIGetPatrolCameraByNameStreamRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolCameraByNameStream(ctx context.Context, name string) PatrolAPIGetPatrolCameraByNameStreamRequest {
|
|
return PatrolAPIGetPatrolCameraByNameStreamRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolStreamOut
|
|
func (a *PatrolAPIService) GetPatrolCameraByNameStreamExecute(r PatrolAPIGetPatrolCameraByNameStreamRequest) (*PatrolPatrolStreamOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolStreamOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolCameraByNameStream")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/camera/{name}/stream"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolCameraByNameStreamByTicketRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
ticket string
|
|
expires *string
|
|
}
|
|
|
|
// Expires is the moment the tag covers, as the seconds the minted address carries in its `expires` parameter.
|
|
func (r PatrolAPIGetPatrolCameraByNameStreamByTicketRequest) Expires(expires string) PatrolAPIGetPatrolCameraByNameStreamByTicketRequest {
|
|
r.expires = &expires
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolCameraByNameStreamByTicketRequest) Execute() (*PatrolPatrolTicketOut, *http.Response, error) {
|
|
return r.ApiService.GetPatrolCameraByNameStreamByTicketExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolCameraByNameStreamByTicket Redeems a minted ticket for what opens the camera.
|
|
|
|
Redeems a minted ticket for what opens the camera.
|
|
|
|
The mint is the operation's — staff only — and it hands back the camera's
|
|
address with the credential stripped out of it. This is where the holder of
|
|
that address gets what actually dials the camera, and it asks for no
|
|
credential of its own: whatever opens a camera is a relay, not a member of the
|
|
operation, and a check only the issuer could perform checks nothing.
|
|
|
|
The ticket IS the authority. It names one camera, it covers one moment, and it
|
|
is tagged with a key nobody but this deployment holds, so holding a live one is
|
|
the right to open that camera until it runs out — which is the whole of what
|
|
was issued, and the reason issuing one is staff-only and five minutes long.
|
|
|
|
A tag that does not verify is 404 — the route is no oracle on which tenants or
|
|
cameras exist, or which tickets were ever issued — and one that verifies but
|
|
has passed its moment is 410, because that ticket was real and is over.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the camera's document name, from the path.
|
|
@param ticket Ticket is the tag the minted address carries, from the path.
|
|
@return PatrolAPIGetPatrolCameraByNameStreamByTicketRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolCameraByNameStreamByTicket(ctx context.Context, name string, ticket string) PatrolAPIGetPatrolCameraByNameStreamByTicketRequest {
|
|
return PatrolAPIGetPatrolCameraByNameStreamByTicketRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
ticket: ticket,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolTicketOut
|
|
func (a *PatrolAPIService) GetPatrolCameraByNameStreamByTicketExecute(r PatrolAPIGetPatrolCameraByNameStreamByTicketRequest) (*PatrolPatrolTicketOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolTicketOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolCameraByNameStreamByTicket")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/camera/{name}/stream/{ticket}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
localVarPath = strings.Replace(localVarPath, "{"+"ticket"+"}", url.PathEscape(parameterValueToString(r.ticket, "ticket")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.expires != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "expires", r.expires, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolEventRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
level *string
|
|
limit *int64
|
|
}
|
|
|
|
// Level narrows the list to red, amber, green or cyan. Empty lists every level.
|
|
func (r PatrolAPIGetPatrolEventRequest) Level(level string) PatrolAPIGetPatrolEventRequest {
|
|
r.level = &level
|
|
return r
|
|
}
|
|
|
|
// Limit caps how many rows are returned. Anything that is not a positive integer uses 80, and higher values are clamped to 80.
|
|
func (r PatrolAPIGetPatrolEventRequest) Limit(limit int64) PatrolAPIGetPatrolEventRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolEventRequest) Execute() (*PatrolPatrolEventList, *http.Response, error) {
|
|
return r.ApiService.GetPatrolEventExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolEvent Lists the feed, newest first.
|
|
|
|
Lists the feed, newest first. It is the same rows the live stream
|
|
carries, read back for a screen that has just opened — so the window is the
|
|
newest rows, or a screen that reloads reads a feed that stopped on the day the
|
|
tenant was installed.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolEventRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolEvent(ctx context.Context) PatrolAPIGetPatrolEventRequest {
|
|
return PatrolAPIGetPatrolEventRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolEventList
|
|
func (a *PatrolAPIService) GetPatrolEventExecute(r PatrolAPIGetPatrolEventRequest) (*PatrolPatrolEventList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolEventList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolEvent")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/event"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.level != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "level", r.level, "form", "")
|
|
}
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolFeedRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolFeedRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.GetPatrolFeedExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolFeed Watch the live feed
|
|
|
|
Holds a Server-Sent Events connection open and writes every change in the picture as it happens: a unit's position, an incident moving, a feed row, a checkpoint confirmed. Each record is one `data:` line carrying a JSON frame whose `kind` says which of the four it is, terminated by a blank line; a comment line arrives every 25 seconds so an idle connection stays open.
|
|
|
|
It carries the caller's own org and no other. ?since=<YYYY-MM-DD HH:MM:SS> replays the feed rows written at or after that moment before the stream goes live, so a reader that reconnected misses nothing it can still see. The list routes are the truth and the stream is a live hint: a dropped frame costs one refresh.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolFeedRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolFeed(ctx context.Context) PatrolAPIGetPatrolFeedRequest {
|
|
return PatrolAPIGetPatrolFeedRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *PatrolAPIService) GetPatrolFeedExecute(r PatrolAPIGetPatrolFeedRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolFeed")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/feed"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolIncidentRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
open *int64
|
|
limit *int64
|
|
}
|
|
|
|
// Open lists only the incidents that are not closed when it is 1.
|
|
func (r PatrolAPIGetPatrolIncidentRequest) Open(open int64) PatrolAPIGetPatrolIncidentRequest {
|
|
r.open = &open
|
|
return r
|
|
}
|
|
|
|
// Limit caps how many are returned. Anything that is not a positive integer uses 50, and higher values are clamped to 50.
|
|
func (r PatrolAPIGetPatrolIncidentRequest) Limit(limit int64) PatrolAPIGetPatrolIncidentRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolIncidentRequest) Execute() (*PatrolPatrolIncidentList, *http.Response, error) {
|
|
return r.ApiService.GetPatrolIncidentExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolIncident Lists responses.
|
|
|
|
Lists responses. ?open=1 narrows it to the ones still running.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolIncidentRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolIncident(ctx context.Context) PatrolAPIGetPatrolIncidentRequest {
|
|
return PatrolAPIGetPatrolIncidentRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolIncidentList
|
|
func (a *PatrolAPIService) GetPatrolIncidentExecute(r PatrolAPIGetPatrolIncidentRequest) (*PatrolPatrolIncidentList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolIncidentList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolIncident")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/incident"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.open != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "open", r.open, "form", "")
|
|
}
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolIncidentByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolIncidentByNameRequest) Execute() (*PatrolPatrolIncidentOut, *http.Response, error) {
|
|
return r.ApiService.GetPatrolIncidentByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolIncidentByName Returns one response whole: the incident, every act performed on it, and the SLA clocks those acts settled.
|
|
|
|
Returns one response whole: the incident, every act performed on it,
|
|
and the SLA clocks those acts settled. The clocks are derived from the stamps
|
|
and stored nowhere.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the incident's document name, from the path.
|
|
@return PatrolAPIGetPatrolIncidentByNameRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolIncidentByName(ctx context.Context, name string) PatrolAPIGetPatrolIncidentByNameRequest {
|
|
return PatrolAPIGetPatrolIncidentByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolIncidentOut
|
|
func (a *PatrolAPIService) GetPatrolIncidentByNameExecute(r PatrolAPIGetPatrolIncidentByNameRequest) (*PatrolPatrolIncidentOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolIncidentOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolIncidentByName")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/incident/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolKeyRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolKeyRequest) Execute() (*PatrolPatrolKeyList, *http.Response, error) {
|
|
return r.ApiService.GetPatrolKeyExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolKey Lists the key register.
|
|
|
|
Lists the key register. Neither the officer nor the client reaches it:
|
|
patrol.key is its own DocType and its permissions name neither, so there is no
|
|
key row for either to read.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolKeyRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolKey(ctx context.Context) PatrolAPIGetPatrolKeyRequest {
|
|
return PatrolAPIGetPatrolKeyRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolKeyList
|
|
func (a *PatrolAPIService) GetPatrolKeyExecute(r PatrolAPIGetPatrolKeyRequest) (*PatrolPatrolKeyList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolKeyList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolKey")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/key"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolKeyByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolKeyByNameRequest) Execute() (*PatrolPatrolKeyOut, *http.Response, error) {
|
|
return r.ApiService.GetPatrolKeyByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolKeyByName Returns one key set from the register.
|
|
|
|
Returns one key set from the register.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the key set's reference, from the path.
|
|
@return PatrolAPIGetPatrolKeyByNameRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolKeyByName(ctx context.Context, name string) PatrolAPIGetPatrolKeyByNameRequest {
|
|
return PatrolAPIGetPatrolKeyByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolKeyOut
|
|
func (a *PatrolAPIService) GetPatrolKeyByNameExecute(r PatrolAPIGetPatrolKeyByNameRequest) (*PatrolPatrolKeyOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolKeyOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolKeyByName")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/key/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolNoteRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
subject *string
|
|
}
|
|
|
|
// Subject narrows the list to one subject by exact match. Empty lists every note.
|
|
func (r PatrolAPIGetPatrolNoteRequest) Subject(subject string) PatrolAPIGetPatrolNoteRequest {
|
|
r.subject = &subject
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolNoteRequest) Execute() (*PatrolPatrolNoteList, *http.Response, error) {
|
|
return r.ApiService.GetPatrolNoteExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolNote Lists internal remarks.
|
|
|
|
Lists internal remarks. The client never reaches them: patrol.note is
|
|
its own DocType and its permissions do not name the client, so there is no
|
|
note row for a customer to read.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolNoteRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolNote(ctx context.Context) PatrolAPIGetPatrolNoteRequest {
|
|
return PatrolAPIGetPatrolNoteRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolNoteList
|
|
func (a *PatrolAPIService) GetPatrolNoteExecute(r PatrolAPIGetPatrolNoteRequest) (*PatrolPatrolNoteList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolNoteList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolNote")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/note"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.subject != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "subject", r.subject, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolReportByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolReportByNameRequest) Execute() (*http.Response, error) {
|
|
return r.ApiService.GetPatrolReportByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolReportByName Download a filed report
|
|
|
|
Renders a filed report as a PDF and answers with the bytes under an attachment filename. ?format=text answers the stored text verbatim under text/plain, which is what a copy button reads.
|
|
|
|
Everyone but the customer may read every report; a client reads only a report about a site of their own, and anything else is 404 rather than a refusal, so the route is no existence oracle. A report whose text cannot be set answers that text rather than failing, because the account is the thing being asked for.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name
|
|
@return PatrolAPIGetPatrolReportByNameRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolReportByName(ctx context.Context, name string) PatrolAPIGetPatrolReportByNameRequest {
|
|
return PatrolAPIGetPatrolReportByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
func (a *PatrolAPIService) GetPatrolReportByNameExecute(r PatrolAPIGetPatrolReportByNameRequest) (*http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolReportByName")
|
|
if err != nil {
|
|
return nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/report/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
return localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolSiteRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
limit *int64
|
|
status *string
|
|
}
|
|
|
|
// Limit caps how many sites are returned. Anything that is not a positive integer uses 500, and higher values are clamped to 500.
|
|
func (r PatrolAPIGetPatrolSiteRequest) Limit(limit int64) PatrolAPIGetPatrolSiteRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
// Status narrows the list to ok, fault, alarm or offline. Empty lists every status.
|
|
func (r PatrolAPIGetPatrolSiteRequest) Status(status string) PatrolAPIGetPatrolSiteRequest {
|
|
r.status = &status
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolSiteRequest) Execute() (*PatrolPatrolSiteList, *http.Response, error) {
|
|
return r.ApiService.GetPatrolSiteExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolSite Lists the estate.
|
|
|
|
Lists the estate. A client sees only the sites their own customer
|
|
record owns, filtered from their role rather than from anything they sent.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolSiteRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolSite(ctx context.Context) PatrolAPIGetPatrolSiteRequest {
|
|
return PatrolAPIGetPatrolSiteRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolSiteList
|
|
func (a *PatrolAPIService) GetPatrolSiteExecute(r PatrolAPIGetPatrolSiteRequest) (*PatrolPatrolSiteList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolSiteList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolSite")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/site"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
if r.status != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "status", r.status, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolSiteByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolSiteByNameRequest) Execute() (*PatrolPatrolSiteOut, *http.Response, error) {
|
|
return r.ApiService.GetPatrolSiteByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolSiteByName Returns one site whole: the register row plus the panel's zones and the standing hazards, which ride inside the document.
|
|
|
|
Returns one site whole: the register row plus the panel's zones and the
|
|
standing hazards, which ride inside the document. A client asking for a site
|
|
that is not theirs is 404.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the site's document name, from the path.
|
|
@return PatrolAPIGetPatrolSiteByNameRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolSiteByName(ctx context.Context, name string) PatrolAPIGetPatrolSiteByNameRequest {
|
|
return PatrolAPIGetPatrolSiteByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolSiteOut
|
|
func (a *PatrolAPIService) GetPatrolSiteByNameExecute(r PatrolAPIGetPatrolSiteByNameRequest) (*PatrolPatrolSiteOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolSiteOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolSiteByName")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/site/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolSnapshotRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
events *int64
|
|
}
|
|
|
|
// Events caps how many feed rows ride along. Anything that is not a positive integer uses 80, and higher values are clamped to 80.
|
|
func (r PatrolAPIGetPatrolSnapshotRequest) Events(events int64) PatrolAPIGetPatrolSnapshotRequest {
|
|
r.events = &events
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolSnapshotRequest) Execute() (*PatrolPatrolSnapshotOut, *http.Response, error) {
|
|
return r.ApiService.GetPatrolSnapshotExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolSnapshot Returns the whole picture in one read: sites, units with their position trails, today's tours and checkpoints, the key register, the recent feed and the open incident.
|
|
|
|
Returns the whole picture in one read: sites, units with their
|
|
position trails, today's tours and checkpoints, the key register, the recent
|
|
feed and the open incident. It replaces the five separate list calls the
|
|
screen used to make. A client sees only their own sites, and the key register
|
|
is empty for anyone whose roles do not reach it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolSnapshotRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolSnapshot(ctx context.Context) PatrolAPIGetPatrolSnapshotRequest {
|
|
return PatrolAPIGetPatrolSnapshotRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolSnapshotOut
|
|
func (a *PatrolAPIService) GetPatrolSnapshotExecute(r PatrolAPIGetPatrolSnapshotRequest) (*PatrolPatrolSnapshotOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolSnapshotOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolSnapshot")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/snapshot"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.events != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "events", r.events, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolTenantByOrgRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
org string
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolTenantByOrgRequest) Execute() (*PatrolPatrolTenantOut, *http.Response, error) {
|
|
return r.ApiService.GetPatrolTenantByOrgExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolTenantByOrg Returns one org's public face — brand, company, operations, features and terminology.
|
|
|
|
Returns one org's public face — brand, company, operations, features
|
|
and terminology. It is the one anonymous route here: the front end loads it
|
|
before anyone signs in. It carries no contact list and nothing operational,
|
|
and an org with no tenant document is 404.
|
|
|
|
The org is a name a stranger supplied, so the read asks whether the deployment
|
|
already holds that tenant before it opens anything. Resolving a store CREATES
|
|
one, and a caller naming a fresh org on every request would leave a database
|
|
per name they invented.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param org Org is the IAM org the tenant belongs to, from the path.
|
|
@return PatrolAPIGetPatrolTenantByOrgRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolTenantByOrg(ctx context.Context, org string) PatrolAPIGetPatrolTenantByOrgRequest {
|
|
return PatrolAPIGetPatrolTenantByOrgRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
org: org,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolTenantOut
|
|
func (a *PatrolAPIService) GetPatrolTenantByOrgExecute(r PatrolAPIGetPatrolTenantByOrgRequest) (*PatrolPatrolTenantOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolTenantOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolTenantByOrg")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/tenant/{org}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"org"+"}", url.PathEscape(parameterValueToString(r.org, "org")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolTourRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
date *string
|
|
}
|
|
|
|
// Date narrows the list to one day, as YYYY-MM-DD. \"today\" means today. Empty lists every round held.
|
|
func (r PatrolAPIGetPatrolTourRequest) Date(date string) PatrolAPIGetPatrolTourRequest {
|
|
r.date = &date
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolTourRequest) Execute() (*PatrolPatrolTourList, *http.Response, error) {
|
|
return r.ApiService.GetPatrolTourExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolTour Lists patrol rounds with their checkpoints — the proof-of-presence record.
|
|
|
|
Lists patrol rounds with their checkpoints — the proof-of-presence
|
|
record. ?date=today narrows it to the current day.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolTourRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolTour(ctx context.Context) PatrolAPIGetPatrolTourRequest {
|
|
return PatrolAPIGetPatrolTourRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolTourList
|
|
func (a *PatrolAPIService) GetPatrolTourExecute(r PatrolAPIGetPatrolTourRequest) (*PatrolPatrolTourList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolTourList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolTour")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/tour"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.date != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "date", r.date, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolUnitRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolUnitRequest) Execute() (*PatrolPatrolUnitList, *http.Response, error) {
|
|
return r.ApiService.GetPatrolUnitExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolUnit Lists the fleet with each unit's position trail, which is what the map draws.
|
|
|
|
Lists the fleet with each unit's position trail, which is what the map
|
|
draws. It is the operation's own: a unit names no site, so a customer reads
|
|
none of it — the officer crewing one is the company's staff, and the trail is
|
|
where that person has been all shift.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolUnitRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolUnit(ctx context.Context) PatrolAPIGetPatrolUnitRequest {
|
|
return PatrolAPIGetPatrolUnitRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolUnitList
|
|
func (a *PatrolAPIService) GetPatrolUnitExecute(r PatrolAPIGetPatrolUnitRequest) (*PatrolPatrolUnitList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolUnitList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolUnit")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/unit"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIGetPatrolUnitNearRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
site *string
|
|
limit *int64
|
|
}
|
|
|
|
// Site is the site to measure from, by document name.
|
|
func (r PatrolAPIGetPatrolUnitNearRequest) Site(site string) PatrolAPIGetPatrolUnitNearRequest {
|
|
r.site = &site
|
|
return r
|
|
}
|
|
|
|
// Limit caps how many units come back. Anything that is not a positive integer uses 3, and higher values are clamped to 10.
|
|
func (r PatrolAPIGetPatrolUnitNearRequest) Limit(limit int64) PatrolAPIGetPatrolUnitNearRequest {
|
|
r.limit = &limit
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIGetPatrolUnitNearRequest) Execute() (*PatrolPatrolNearList, *http.Response, error) {
|
|
return r.ApiService.GetPatrolUnitNearExecute(r)
|
|
}
|
|
|
|
/*
|
|
GetPatrolUnitNear Answers which units can reach a site soonest.
|
|
|
|
Answers which units can reach a site soonest. Distance is a great-circle
|
|
haversine over the units' last reported positions, and an available unit sorts
|
|
ahead of a busy one at any distance — a controller asking for the nearest unit
|
|
is asking for the nearest free one.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIGetPatrolUnitNearRequest
|
|
*/
|
|
func (a *PatrolAPIService) GetPatrolUnitNear(ctx context.Context) PatrolAPIGetPatrolUnitNearRequest {
|
|
return PatrolAPIGetPatrolUnitNearRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolNearList
|
|
func (a *PatrolAPIService) GetPatrolUnitNearExecute(r PatrolAPIGetPatrolUnitNearRequest) (*PatrolPatrolNearList, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodGet
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolNearList
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.GetPatrolUnitNear")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/unit/near"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
|
|
if r.site != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "site", r.site, "form", "")
|
|
}
|
|
if r.limit != nil {
|
|
parameterAddToHeaderOrQuery(localVarQueryParams, "limit", r.limit, "form", "")
|
|
}
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolAlarmRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
patrolPatrolAlarmIn *PatrolPatrolAlarmIn
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolAlarmRequest) PatrolPatrolAlarmIn(patrolPatrolAlarmIn PatrolPatrolAlarmIn) PatrolAPIPostPatrolAlarmRequest {
|
|
r.patrolPatrolAlarmIn = &patrolPatrolAlarmIn
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolAlarmRequest) Execute() (*PatrolPatrolAlarmOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolAlarmExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolAlarm Takes one activation.
|
|
|
|
Takes one activation. It records the activation whatever happens, then
|
|
matches a site — the one the caller named, else the one whose account number
|
|
reported — and on a match opens an incident in state received with that site's
|
|
tier and SLA, puts the site into alarm, raises a red feed row and tells the
|
|
controllers. An activation that matches no site is still recorded, raises an
|
|
amber row, and answers 202: an activation is never dropped.
|
|
|
|
It admits the receiving centre's own credential and a controller keying one in
|
|
by hand. The centre holds the `centre` role its tenant granted it, which posts
|
|
an activation and reads nothing, like every other identity here.
|
|
|
|
The centre's own reference identifies the activation while the response it
|
|
opened is still running, so a redelivery is answered with that response rather
|
|
than dispatching a second unit. Centres recycle references, so once the
|
|
response has closed the same one is the next activation.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIPostPatrolAlarmRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolAlarm(ctx context.Context) PatrolAPIPostPatrolAlarmRequest {
|
|
return PatrolAPIPostPatrolAlarmRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolAlarmOut
|
|
func (a *PatrolAPIService) PostPatrolAlarmExecute(r PatrolAPIPostPatrolAlarmRequest) (*PatrolPatrolAlarmOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolAlarmOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolAlarm")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/alarm"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolAlarmIn == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolAlarmIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolAlarmIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolEventRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
patrolPatrolEventIn *PatrolPatrolEventIn
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolEventRequest) PatrolPatrolEventIn(patrolPatrolEventIn PatrolPatrolEventIn) PatrolAPIPostPatrolEventRequest {
|
|
r.patrolPatrolEventIn = &patrolPatrolEventIn
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolEventRequest) Execute() (*PatrolPatrolEventOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolEventExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolEvent Writes one feed row by hand and pushes it to every screen watching.
|
|
|
|
Writes one feed row by hand and pushes it to every screen watching.
|
|
It is how a controller puts something on the record that no automatic write
|
|
would have produced.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIPostPatrolEventRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolEvent(ctx context.Context) PatrolAPIPostPatrolEventRequest {
|
|
return PatrolAPIPostPatrolEventRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolEventOut
|
|
func (a *PatrolAPIService) PostPatrolEventExecute(r PatrolAPIPostPatrolEventRequest) (*PatrolPatrolEventOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolEventOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolEvent")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/event"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolEventIn == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolEventIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolEventIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolIncidentRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
patrolPatrolIncidentIn *PatrolPatrolIncidentIn
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolIncidentRequest) PatrolPatrolIncidentIn(patrolPatrolIncidentIn PatrolPatrolIncidentIn) PatrolAPIPostPatrolIncidentRequest {
|
|
r.patrolPatrolIncidentIn = &patrolPatrolIncidentIn
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolIncidentRequest) Execute() (*PatrolPatrolIncidentOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolIncidentExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolIncident Records a response by hand, in state received and carrying the site's tier and SLA.
|
|
|
|
Records a response by hand, in state received and carrying the
|
|
site's tier and SLA. It is what a controller calls when an activation arrives
|
|
by phone rather than over the intake.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIPostPatrolIncidentRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolIncident(ctx context.Context) PatrolAPIPostPatrolIncidentRequest {
|
|
return PatrolAPIPostPatrolIncidentRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolIncidentOut
|
|
func (a *PatrolAPIService) PostPatrolIncidentExecute(r PatrolAPIPostPatrolIncidentRequest) (*PatrolPatrolIncidentOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolIncidentOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolIncident")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/incident"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolIncidentIn == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolIncidentIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolIncidentIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolIncidentByNameStepRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
patrolPatrolIncidentAct *PatrolPatrolIncidentAct
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolIncidentByNameStepRequest) PatrolPatrolIncidentAct(patrolPatrolIncidentAct PatrolPatrolIncidentAct) PatrolAPIPostPatrolIncidentByNameStepRequest {
|
|
r.patrolPatrolIncidentAct = &patrolPatrolIncidentAct
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolIncidentByNameStepRequest) Execute() (*PatrolPatrolIncidentOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolIncidentByNameStepExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolIncidentByNameStep Performs one act on an incident: it stamps the act's time, moves the state, appends the act to the trail, and runs what the act sets in motion — a unit assigned, a site secured, a report filed, a controller told.
|
|
|
|
Performs one act on an incident: it stamps the act's time, moves
|
|
the state, appends the act to the trail, and runs what the act sets in motion —
|
|
a unit assigned, a site secured, a report filed, a controller told.
|
|
|
|
The states run forward only. An act from a state it does not leave is 409
|
|
naming the state the incident is in, and a caller without the act's roles is
|
|
refused.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the incident's document name, from the path.
|
|
@return PatrolAPIPostPatrolIncidentByNameStepRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolIncidentByNameStep(ctx context.Context, name string) PatrolAPIPostPatrolIncidentByNameStepRequest {
|
|
return PatrolAPIPostPatrolIncidentByNameStepRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolIncidentOut
|
|
func (a *PatrolAPIService) PostPatrolIncidentByNameStepExecute(r PatrolAPIPostPatrolIncidentByNameStepRequest) (*PatrolPatrolIncidentOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolIncidentOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolIncidentByNameStep")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/incident/{name}/step"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolIncidentAct == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolIncidentAct is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolIncidentAct
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolKeyByNameMoveRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
patrolPatrolMoveIn *PatrolPatrolMoveIn
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolKeyByNameMoveRequest) PatrolPatrolMoveIn(patrolPatrolMoveIn PatrolPatrolMoveIn) PatrolAPIPostPatrolKeyByNameMoveRequest {
|
|
r.patrolPatrolMoveIn = &patrolPatrolMoveIn
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolKeyByNameMoveRequest) Execute() (*PatrolPatrolKeyOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolKeyByNameMoveExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolKeyByNameMove Records a key set leaving, returning, or being counted, and moves the register row to match.
|
|
|
|
Records a key set leaving, returning, or being counted, and moves the
|
|
register row to match. The register says where a set is now and the movements
|
|
say how it got there, so a movement is written once and never edited.
|
|
|
|
Who signed for the move is the caller, stamped from the request. A body that
|
|
named the signer would make the chain of custody a value the signer chose.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the key set's reference, from the path.
|
|
@return PatrolAPIPostPatrolKeyByNameMoveRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolKeyByNameMove(ctx context.Context, name string) PatrolAPIPostPatrolKeyByNameMoveRequest {
|
|
return PatrolAPIPostPatrolKeyByNameMoveRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolKeyOut
|
|
func (a *PatrolAPIService) PostPatrolKeyByNameMoveExecute(r PatrolAPIPostPatrolKeyByNameMoveRequest) (*PatrolPatrolKeyOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolKeyOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolKeyByNameMove")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/key/{name}/move"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolMoveIn == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolMoveIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolMoveIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolNoteRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
patrolPatrolNoteIn *PatrolPatrolNoteIn
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolNoteRequest) PatrolPatrolNoteIn(patrolPatrolNoteIn PatrolPatrolNoteIn) PatrolAPIPostPatrolNoteRequest {
|
|
r.patrolPatrolNoteIn = &patrolPatrolNoteIn
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolNoteRequest) Execute() (*PatrolPatrolNoteOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolNoteExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolNote Records an internal remark, stamped with who wrote it.
|
|
|
|
Records an internal remark, stamped with who wrote it.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIPostPatrolNoteRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolNote(ctx context.Context) PatrolAPIPostPatrolNoteRequest {
|
|
return PatrolAPIPostPatrolNoteRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolNoteOut
|
|
func (a *PatrolAPIService) PostPatrolNoteExecute(r PatrolAPIPostPatrolNoteRequest) (*PatrolPatrolNoteOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolNoteOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolNote")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/note"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolNoteIn == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolNoteIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolNoteIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolPointByNameConfirmRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
patrolPatrolConfirmIn *PatrolPatrolConfirmIn
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolPointByNameConfirmRequest) PatrolPatrolConfirmIn(patrolPatrolConfirmIn PatrolPatrolConfirmIn) PatrolAPIPostPatrolPointByNameConfirmRequest {
|
|
r.patrolPatrolConfirmIn = &patrolPatrolConfirmIn
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolPointByNameConfirmRequest) Execute() (*PatrolPatrolCheckpointOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolPointByNameConfirmExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolPointByNameConfirm Records presence at a checkpoint: who confirmed it, the method, where they stood, and the photo key if one was taken.
|
|
|
|
Records presence at a checkpoint: who confirmed it, the method, where
|
|
they stood, and the photo key if one was taken. A confirmation after the
|
|
window shuts is recorded late rather than refused — the visit happened, and a
|
|
report that hides it is worth nothing.
|
|
|
|
An officer confirms their own round and no other, by the same rule a position
|
|
report and every incident act are held to: the checkpoint belongs to a tour,
|
|
the tour names a unit, and the unit names its officer. The record carries the
|
|
actor, so it says who claimed the visit and not merely that somebody did.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the checkpoint's document name, from the path.
|
|
@return PatrolAPIPostPatrolPointByNameConfirmRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolPointByNameConfirm(ctx context.Context, name string) PatrolAPIPostPatrolPointByNameConfirmRequest {
|
|
return PatrolAPIPostPatrolPointByNameConfirmRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolCheckpointOut
|
|
func (a *PatrolAPIService) PostPatrolPointByNameConfirmExecute(r PatrolAPIPostPatrolPointByNameConfirmRequest) (*PatrolPatrolCheckpointOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolCheckpointOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolPointByNameConfirm")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/point/{name}/confirm"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolConfirmIn == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolConfirmIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolConfirmIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolReportRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
patrolPatrolReportIn *PatrolPatrolReportIn
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolReportRequest) PatrolPatrolReportIn(patrolPatrolReportIn PatrolPatrolReportIn) PatrolAPIPostPatrolReportRequest {
|
|
r.patrolPatrolReportIn = &patrolPatrolReportIn
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolReportRequest) Execute() (*PatrolPatrolReportOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolReportExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolReport Composes and files a report from one estate read, so the same figures read the same a month later.
|
|
|
|
Composes and files a report from one estate read, so the same
|
|
figures read the same a month later. The text is stored on the document; the
|
|
PDF is produced on read at /v1/patrol/report/{name}.
|
|
|
|
A client report naming a customer is an account of that customer's estate and
|
|
is theirs to download; naming none covers every customer, which is an account
|
|
of the operation.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@return PatrolAPIPostPatrolReportRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolReport(ctx context.Context) PatrolAPIPostPatrolReportRequest {
|
|
return PatrolAPIPostPatrolReportRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolReportOut
|
|
func (a *PatrolAPIService) PostPatrolReportExecute(r PatrolAPIPostPatrolReportRequest) (*PatrolPatrolReportOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolReportOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolReport")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/report"
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolReportIn == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolReportIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolReportIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolUnitByNameFixRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
patrolPatrolFixIn *PatrolPatrolFixIn
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolUnitByNameFixRequest) PatrolPatrolFixIn(patrolPatrolFixIn PatrolPatrolFixIn) PatrolAPIPostPatrolUnitByNameFixRequest {
|
|
r.patrolPatrolFixIn = &patrolPatrolFixIn
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolUnitByNameFixRequest) Execute() (*PatrolPatrolFixOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolUnitByNameFixExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolUnitByNameFix Records where a unit is.
|
|
|
|
Records where a unit is. It appends the position to the unit's trail,
|
|
moves the unit's own coordinates and last-seen stamp, and publishes one frame
|
|
to every screen watching. An officer may report only their own unit; the
|
|
control room may report any.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the unit's call sign, from the path.
|
|
@return PatrolAPIPostPatrolUnitByNameFixRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolUnitByNameFix(ctx context.Context, name string) PatrolAPIPostPatrolUnitByNameFixRequest {
|
|
return PatrolAPIPostPatrolUnitByNameFixRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolFixOut
|
|
func (a *PatrolAPIService) PostPatrolUnitByNameFixExecute(r PatrolAPIPostPatrolUnitByNameFixRequest) (*PatrolPatrolFixOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolFixOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolUnitByNameFix")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/unit/{name}/fix"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolFixIn == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolFixIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolFixIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPostPatrolUnitByNameStateRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
patrolPatrolUnitStateIn *PatrolPatrolUnitStateIn
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolUnitByNameStateRequest) PatrolPatrolUnitStateIn(patrolPatrolUnitStateIn PatrolPatrolUnitStateIn) PatrolAPIPostPatrolUnitByNameStateRequest {
|
|
r.patrolPatrolUnitStateIn = &patrolPatrolUnitStateIn
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPostPatrolUnitByNameStateRequest) Execute() (*PatrolPatrolUnitOut, *http.Response, error) {
|
|
return r.ApiService.PostPatrolUnitByNameStateExecute(r)
|
|
}
|
|
|
|
/*
|
|
PostPatrolUnitByNameState Moves a unit between states — on shift, on a break, off, or in trouble.
|
|
|
|
Moves a unit between states — on shift, on a break, off, or in
|
|
trouble. An officer may move only their own unit; the control room may move
|
|
any.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the unit's call sign, from the path.
|
|
@return PatrolAPIPostPatrolUnitByNameStateRequest
|
|
*/
|
|
func (a *PatrolAPIService) PostPatrolUnitByNameState(ctx context.Context, name string) PatrolAPIPostPatrolUnitByNameStateRequest {
|
|
return PatrolAPIPostPatrolUnitByNameStateRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolUnitOut
|
|
func (a *PatrolAPIService) PostPatrolUnitByNameStateExecute(r PatrolAPIPostPatrolUnitByNameStateRequest) (*PatrolPatrolUnitOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPost
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolUnitOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PostPatrolUnitByNameState")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/unit/{name}/state"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolUnitStateIn == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolUnitStateIn is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolUnitStateIn
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|
|
|
|
type PatrolAPIPutPatrolSiteByNameRequest struct {
|
|
ctx context.Context
|
|
ApiService *PatrolAPIService
|
|
name string
|
|
patrolPatrolSiteEdit *PatrolPatrolSiteEdit
|
|
}
|
|
|
|
func (r PatrolAPIPutPatrolSiteByNameRequest) PatrolPatrolSiteEdit(patrolPatrolSiteEdit PatrolPatrolSiteEdit) PatrolAPIPutPatrolSiteByNameRequest {
|
|
r.patrolPatrolSiteEdit = &patrolPatrolSiteEdit
|
|
return r
|
|
}
|
|
|
|
func (r PatrolAPIPutPatrolSiteByNameRequest) Execute() (*PatrolPatrolSiteOut, *http.Response, error) {
|
|
return r.ApiService.PutPatrolSiteByNameExecute(r)
|
|
}
|
|
|
|
/*
|
|
PutPatrolSiteByName Changes a site's contract and brief fields.
|
|
|
|
Changes a site's contract and brief fields. It leaves absent fields
|
|
as they stand, and it never moves the account number, the coordinates or the
|
|
customer — those are register facts, changed through the framework surface.
|
|
|
|
@param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
|
|
@param name Name is the site's document name, from the path.
|
|
@return PatrolAPIPutPatrolSiteByNameRequest
|
|
*/
|
|
func (a *PatrolAPIService) PutPatrolSiteByName(ctx context.Context, name string) PatrolAPIPutPatrolSiteByNameRequest {
|
|
return PatrolAPIPutPatrolSiteByNameRequest{
|
|
ApiService: a,
|
|
ctx: ctx,
|
|
name: name,
|
|
}
|
|
}
|
|
|
|
// Execute executes the request
|
|
//
|
|
// @return PatrolPatrolSiteOut
|
|
func (a *PatrolAPIService) PutPatrolSiteByNameExecute(r PatrolAPIPutPatrolSiteByNameRequest) (*PatrolPatrolSiteOut, *http.Response, error) {
|
|
var (
|
|
localVarHTTPMethod = http.MethodPut
|
|
localVarPostBody interface{}
|
|
formFiles []formFile
|
|
localVarReturnValue *PatrolPatrolSiteOut
|
|
)
|
|
|
|
localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "PatrolAPIService.PutPatrolSiteByName")
|
|
if err != nil {
|
|
return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
|
|
}
|
|
|
|
localVarPath := localBasePath + "/v1/patrol/site/{name}"
|
|
localVarPath = strings.Replace(localVarPath, "{"+"name"+"}", url.PathEscape(parameterValueToString(r.name, "name")), -1)
|
|
|
|
localVarHeaderParams := make(map[string]string)
|
|
localVarQueryParams := url.Values{}
|
|
localVarFormParams := url.Values{}
|
|
if r.patrolPatrolSiteEdit == nil {
|
|
return localVarReturnValue, nil, reportError("patrolPatrolSiteEdit is required and must be specified")
|
|
}
|
|
|
|
// to determine the Content-Type header
|
|
localVarHTTPContentTypes := []string{"application/json"}
|
|
|
|
// set Content-Type header
|
|
localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
|
|
if localVarHTTPContentType != "" {
|
|
localVarHeaderParams["Content-Type"] = localVarHTTPContentType
|
|
}
|
|
|
|
// to determine the Accept header
|
|
localVarHTTPHeaderAccepts := []string{"application/json", "application/problem+json"}
|
|
|
|
// set Accept header
|
|
localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
|
|
if localVarHTTPHeaderAccept != "" {
|
|
localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
|
|
}
|
|
// body params
|
|
localVarPostBody = r.patrolPatrolSiteEdit
|
|
req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
|
|
if err != nil {
|
|
return localVarReturnValue, nil, err
|
|
}
|
|
|
|
localVarHTTPResponse, err := a.client.callAPI(req)
|
|
if err != nil || localVarHTTPResponse == nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
|
|
localVarHTTPResponse.Body.Close()
|
|
localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
|
|
if err != nil {
|
|
return localVarReturnValue, localVarHTTPResponse, err
|
|
}
|
|
|
|
if localVarHTTPResponse.StatusCode >= 300 {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: localVarHTTPResponse.Status,
|
|
}
|
|
var v ProblemDetails
|
|
err = a.client.decode(&v, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr.error = err.Error()
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
newErr.error = formatErrorMessage(localVarHTTPResponse.Status, &v)
|
|
newErr.model = v
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
|
|
if err != nil {
|
|
newErr := &GenericOpenAPIError{
|
|
body: localVarBody,
|
|
error: err.Error(),
|
|
}
|
|
return localVarReturnValue, localVarHTTPResponse, newErr
|
|
}
|
|
|
|
return localVarReturnValue, localVarHTTPResponse, nil
|
|
}
|