Package com.qtsurfer.api.client.model

Class StartLiveRequest

java.lang.Object
com.qtsurfer.api.client.model.StartLiveRequest
@Generated(value="org.openapitools.codegen.languages.JavaClientCodegen", comments="Generator version: 7.24.0") public class StartLiveRequest extends Object
StartLiveRequest

  • Field Details

  • Constructor Details

    • StartLiveRequest

      public StartLiveRequest()

  • Method Details

    • sources

      public StartLiveRequest sources(@Nonnull List<LiveSourceRequest> sources)

    • addSourcesItem

      public StartLiveRequest addSourcesItem(LiveSourceRequest sourcesItem)

    • getSources

      @Nonnull public List<LiveSourceRequest> getSources()
      Get sources
      Returns:
      sources

    • setSources

      public void setSources(@Nonnull List<LiveSourceRequest> sources)

    • params

      public StartLiveRequest params(@Nullable Map<String,Object> params)

    • putParamsItem

      public StartLiveRequest putParamsItem(String key, Object paramsItem)

    • getParams

      @Nullable public Map<String,Object> getParams()
      Strategy parameters to start with. Opaque key/value pairs — see this strategy's own `declaredProperties` (from `POST /strategy`) for the keys it accepts.
      Returns:
      params

    • setParams

      public void setParams(@Nullable Map<String,Object> params)

    • visibility

      public StartLiveRequest visibility(@Nullable StartLiveRequest.VisibilityEnum visibility)

    • getVisibility

      @Nullable public StartLiveRequest.VisibilityEnum getVisibility()
      A `public` run appears in `GET /live/public` and its signal channel accepts subscriptions from anyone, not only you — from the moment it is in the `live` stage, which is when it is promoted or, for a run that starts there, at once. While it is a `sandbox` trial, `public` is only what you asked for, and only you can read it.
      Returns:
      visibility

    • setVisibility

      public void setVisibility(@Nullable StartLiveRequest.VisibilityEnum visibility)

    • relay

      public StartLiveRequest relay(@Nullable Boolean relay)

    • getRelay

      @Nullable public Boolean getRelay()
      Request that this run's signals be relayed over its WebSocket channel, from its first signal — in the `sandbox` stage too, where only you can subscribe to it. See the \"Live execution\" guide.
      Returns:
      relay

    • setRelay

      public void setRelay(@Nullable Boolean relay)

    • sandbox

      public StartLiveRequest sandbox(@Nullable Boolean sandbox)

    • getSandbox

      @Nullable public Boolean getSandbox()
      Start in the `sandbox` stage even though an earlier run of yours already took this compiled strategy through it. Without it, such a strategy starts in `LIVE` at once; with `true` it starts in `SANDBOX` like a first run, which is how to read its signals back over the connection (`history`, kept for the `sandbox` stage only) while you debug it. For a strategy that has not been through the sandbox it changes nothing: it always starts there. Anything other than `true` or `false` is `400`.
      Returns:
      sandbox

    • setSandbox

      public void setSandbox(@Nullable Boolean sandbox)

    • stream

      public StartLiveRequest stream(@Nullable Boolean stream)

    • getStream

      @Nullable public Boolean getStream()
      Ask for a **stream URL**: a secret address that a simple client, or a service that passes your signals on to others, can open as a plain WebSocket to receive this run's signals as they are produced, one JSON text frame per signal, with none of the live-execution protocol around it. The URL comes back as `streamUrl` in the response to this call. Available from the `sandbox` stage on, on the plans that may broadcast; any other plan gets `429`. It can be asked for **only when the run is started** (not added later), and it also turns `relay` on. See the \"Live execution\" guide, \"A plain WebSocket stream of a run\".
      Returns:
      stream

    • setStream

      public void setStream(@Nullable Boolean stream)

    • warmFrom

      public StartLiveRequest warmFrom(@Nullable Integer warmFrom)

    • getWarmFrom

      @Nullable public Integer getWarmFrom()
      How many seconds before the run's start to replay the market feed from, so the strategy's indicators and windows have history when its first live tick arrives. `0` replays nothing: the run delivers its first signal as soon as it is running, but its indicators start empty and the first bar of a window can be partial. Omitted, the platform replays from the start of the current 15-minute block: between 0 and 900 seconds before the run's start, depending on when it starts (0 if it starts exactly on a quarter hour), so the first bar of a 15-minute window is complete. The value in effect, the one you sent or the one the platform chose, is reported back as `warmFrom` on the run. Signals about the replayed time are not pushed on the run's channel or stream: they describe events from before the run started. It can be set **only when the run is started**: it is not a parameter of `PUT /live/{runId}/params`, and changing it means stopping the run and starting it again. Anything that is not an integer from 0 to 3600 is `400`. See the \"Live execution\" guide, \"Warming up\". minimum: 0 maximum: 3600
      Returns:
      warmFrom

    • setWarmFrom

      public void setWarmFrom(@Nullable Integer warmFrom)

    • name

      public StartLiveRequest name(@Nullable String name)

    • getName

      @Nullable public String getName()
      Get name
      Returns:
      name

    • setName

      public void setName(@Nullable String name)

    • description

      public StartLiveRequest description(@Nullable String description)

    • getDescription

      @Nullable public String getDescription()
      Get description
      Returns:
      description

    • setDescription

      public void setDescription(@Nullable String description)

    • paper

      public StartLiveRequest paper(@Nullable LivePaperConfig paper)

    • getPaper

      @Nullable public LivePaperConfig getPaper()
      Get paper
      Returns:
      paper

    • setPaper

      public void setPaper(@Nullable LivePaperConfig paper)

    • equals

      public boolean equals(Object o)
      Return true if this StartLiveRequest object is equal to o.
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • toUrlQueryString

      public String toUrlQueryString()
      Convert the instance into URL query string.
      Returns:
      URL query string

    • toUrlQueryString

      public String toUrlQueryString(String prefix)
      Convert the instance into URL query string.
      Parameters:
      prefix - prefix of the query string
      Returns:
      URL query string