# NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
# https://openapi-generator.tech
# Do not edit the class manually.
defmodule ExVcom.Api.Default do
@moduledoc """
API calls for all endpoints tagged `Default`.
"""
alias ExVcom.Connection
import ExVcom.RequestBuilder
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.SystemsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec cmms_systems_get(Tesla.Env.client(), keyword()) ::
{:ok, ExVcom.Model.SystemsResponse.t()} | {:ok, nil} | {:error, Tesla.Env.t()}
def cmms_systems_get(connection, _opts \\ []) do
%{}
|> method(:get)
|> url("/cmms/systems")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.SystemsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.CmmsWorkordersResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec cmms_workorders_get(Tesla.Env.client(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.CmmsWorkordersResponse.t()} | {:error, Tesla.Env.t()}
def cmms_workorders_get(connection, _opts \\ []) do
%{}
|> method(:get)
|> url("/cmms/workorders")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.CmmsWorkordersResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- workorder_id (integer()):
- form_id (integer()):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.CmmsWorkorderFormResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec cmms_workorders_workorder_id_forms_form_id_get(
Tesla.Env.client(),
integer(),
integer(),
keyword()
) ::
{:ok, nil} | {:ok, ExVcom.Model.CmmsWorkorderFormResponse.t()} | {:error, Tesla.Env.t()}
def cmms_workorders_workorder_id_forms_form_id_get(
connection,
workorder_id,
form_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/cmms/workorders/#{workorder_id}/forms/#{form_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.CmmsWorkorderFormResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- workorder_id (integer()):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.CmmsWorkorderFormsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec cmms_workorders_workorder_id_forms_get(Tesla.Env.client(), integer(), keyword()) ::
{:ok, nil}
| {:ok, ExVcom.Model.CmmsWorkorderFormsResponse.t()}
| {:error, Tesla.Env.t()}
def cmms_workorders_workorder_id_forms_get(connection, workorder_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/cmms/workorders/#{workorder_id}/forms")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.CmmsWorkorderFormsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- workorder_id (integer()):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.CmmsWorkorderResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec cmms_workorders_workorder_id_get(Tesla.Env.client(), integer(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.CmmsWorkorderResponse.t()} | {:error, Tesla.Env.t()}
def cmms_workorders_workorder_id_get(connection, workorder_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/cmms/workorders/#{workorder_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.CmmsWorkorderResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- o_auth_login (OAuthLogin):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.OAuthCredentials.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec login_post(Tesla.Env.client(), ExVcom.Model.OAuthLogin.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.OAuthCredentials.t()} | {:error, Tesla.Env.t()}
def login_post(connection, o_auth_login, _opts \\ []) do
%{}
|> method(:post)
|> url("/login")
|> add_param(:body, :body, o_auth_login)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.OAuthCredentials{}},
{400, false},
{401, false},
{429, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.SessionResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec session_get(Tesla.Env.client(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.SessionResponse.t()} | {:error, Tesla.Env.t()}
def session_get(connection, _opts \\ []) do
%{}
|> method(:get)
|> url("/session")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.SessionResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- abbreviation_id (String.t):
- from (DateTime.t): Start date
- to (DateTime.t): End date
- resolution (String.t): Defaults to `day`.
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.SystemMeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_abbreviations_abbreviation_id_measurement_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.SystemMeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_abbreviations_abbreviation_id_measurement_get(
connection,
abbreviation_id,
from,
to,
resolution,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/abbreviations/#{abbreviation_id}/measurement")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_param(:query, :resolution, resolution)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.SystemMeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.SystemsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_abbreviations_get(Tesla.Env.client(), keyword()) ::
{:ok, nil}
| {:ok, ExVcom.Model.SystemsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_abbreviations_get(connection, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.SystemsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.SystemsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_get(Tesla.Env.client(), keyword()) ::
{:ok, ExVcom.Model.SystemsResponse.t()} | {:ok, nil} | {:error, Tesla.Env.t()}
def systems_get(connection, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.SystemsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_basics_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_basics_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/basics/abbreviations/#{abbreviation_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span between `from` and `to` varies depending on the `resolution` as listed below. | Resolution | Maximum time span | |-----------------|-------------------| | interval | 31 days | | fifteen-minutes | 31 days | | thirty-minutes | 31 days | | hour | 31 days | | day | 60 days | | month | 1 year | | year | no limitation |
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`.
- :resolution (String.t): Defaults to `interval`.
## Returns
{:ok, ExVcom.Model.MeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_basics_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.MeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_basics_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/basics/abbreviations/#{abbreviation_id}/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.MeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_basics_abbreviations_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.AbbreviationsResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_basics_abbreviations_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/basics/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to 0
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_basics_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_basics_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/basics/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher).
- :device_ids (String.t): Comma separated deviceIds
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_batteries_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_batteries_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query,
:resolution => :query,
:deviceIds => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/batteries/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_batteries_device_id_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_batteries_device_id_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/batteries/#{device_id}/abbreviations/#{abbreviation_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span between `from` and `to` varies depending on the `resolution` as listed below. | Resolution | Maximum time span | |-----------------|-------------------| | minute | 1 day | | interval | 31 days | | fifteen-minutes | 31 days | | thirty-minutes | 31 days | | hour | 31 days | | day | 60 days | | month | 1 year | | year | no limitation |
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher).
## Returns
{:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_batteries_device_id_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_batteries_device_id_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
device_id,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url(
"/systems/#{system_key}/batteries/#{device_id}/abbreviations/#{abbreviation_id}/measurements"
)
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceMeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_batteries_device_id_abbreviations_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_batteries_device_id_abbreviations_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/batteries/#{device_id}/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.BatteryResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_batteries_device_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.BatteryResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_batteries_device_id_get(connection, system_key, device_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/batteries/#{device_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.BatteryResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.DeviceResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_batteries_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.DeviceResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_batteries_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/batteries")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher) The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :resolution (String.t): Defaults to `interval`.
- :device_ids (String.t): Comma separated deviceIds
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to 0
## Returns
{:ok, ExVcom.Model.BulkMeasurementResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) ::
{:ok, nil} | {:ok, ExVcom.Model.BulkMeasurementResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_bulk_measurements_get(connection, system_key, from, to, opts \\ []) do
optional_params = %{
:format => :query,
:resolution => :query,
:deviceIds => :query,
:abbreviations => :query,
:includeInterval => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.BulkMeasurementResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_calculations_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_calculations_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/calculations/abbreviations/#{abbreviation_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span between `from` and `to` varies depending on the `resolution` as listed below. | Resolution | Maximum time span | |-----------------|-------------------| | day | 60 days | | month | 1 year | | year | no limitation |
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`.
- :resolution (String.t): Defaults to `interval`.
## Returns
{:ok, ExVcom.Model.MeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_calculations_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.MeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_calculations_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/calculations/abbreviations/#{abbreviation_id}/measurements/")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.MeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_calculations_abbreviations_get(
Tesla.Env.client(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationsResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_calculations_abbreviations_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/calculations/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to 0
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_calculations_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_calculations_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/calculations/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- resolution (String.t): Defaults to `interval`.
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.SimulationValueResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_calculations_simulation_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil} | {:ok, ExVcom.Model.SimulationValueResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_calculations_simulation_get(
connection,
system_key,
from,
to,
resolution,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/calculations/simulation")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_param(:query, :resolution, resolution)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.SimulationValueResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
Depending on your contract type different kinds of forecasts are provided. | Category | Description | |--------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Day-Ahead | Only day-ahead forecasts can be retrieved. The first timestamp starts at 00:00:00 of the following day. They are based on numerical weather prediction and will update a couple times per day. | | Intraday | Both day-ahead and intraday forecasts can be retrieved. They are also based on numerical weather prediction and will update a couple times per day. | | Intraday Optimized | Both day-ahead and intraday forecasts can be retrieved. Satellite based forecasts are combined with numerical weather prediction. The forecasts are updated every 15 minutes. |
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
- :hours_into_future (integer()): Between 1 and 96. Defaults to 48.
- :format (String.t): Defaults to `json`.
- :resolution (String.t): Defaults to `fifteen-minutes`.
- :timezone (String.t): Defaults to system timezone
## Returns
{:ok, ExVcom.Model.ForecastResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_forecasts_forecast_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.ForecastResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_forecasts_forecast_get(connection, system_key, opts \\ []) do
optional_params = %{
:hours_into_future => :query,
:format => :query,
:resolution => :query,
:timezone => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/forecasts/forecast")
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.ForecastResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The resolution fixed to month at current moment.
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.MeasurementValueResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_forecasts_yield_specific_energy_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) ::
{:ok, nil} | {:ok, ExVcom.Model.MeasurementValueResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_forecasts_yield_specific_energy_get(
connection,
system_key,
from,
to,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/forecasts/yield/specific-energy")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.MeasurementValueResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.SystemResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.SystemResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.SystemResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher).
- :device_ids (String.t): Comma separated deviceIds
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_inverters_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_inverters_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query,
:resolution => :query,
:deviceIds => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/inverters/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_inverters_device_id_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_inverters_device_id_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/inverters/#{device_id}/abbreviations/#{abbreviation_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span between `from` and `to` varies depending on the `resolution` as listed below. | Resolution | Maximum time span | |-----------------|-------------------| | minute | 1 day | | interval | 31 days | | fifteen-minutes | 31 days | | thirty-minutes | 31 days | | hour | 31 days | | day | 60 days | | month | 1 year | | year | no limitation |
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`.
- :resolution (String.t): Defaults to `interval`.
## Returns
{:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_inverters_device_id_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_inverters_device_id_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
device_id,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url(
"/systems/#{system_key}/inverters/#{device_id}/abbreviations/#{abbreviation_id}/measurements"
)
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceMeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_inverters_device_id_abbreviations_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_inverters_device_id_abbreviations_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/inverters/#{device_id}/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.VirtualMeterDetailsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_inverters_device_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.VirtualMeterDetailsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_inverters_device_id_get(connection, system_key, device_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/inverters/#{device_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.VirtualMeterDetailsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.InverterResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_inverters_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.InverterResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_inverters_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/inverters")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.InverterResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher).
- :device_ids (String.t): Comma separated deviceIds
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_meters_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_meters_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query,
:resolution => :query,
:deviceIds => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/meters/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_meters_device_id_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_meters_device_id_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/meters/#{device_id}/abbreviations/#{abbreviation_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span between `from` and `to` varies depending on the `resolution` as listed below. | Resolution | Maximum time span | |-----------------|-------------------| | minute | 1 day | | interval | 31 days | | fifteen-minutes | 31 days | | thirty-minutes | 31 days | | hour | 31 days | | day | 60 days | | month | 1 year | | year | no limitation |
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`.
- :resolution (String.t): Defaults to `interval`.
## Returns
{:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_meters_device_id_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_meters_device_id_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
device_id,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url(
"/systems/#{system_key}/meters/#{device_id}/abbreviations/#{abbreviation_id}/measurements/"
)
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceMeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_meters_device_id_abbreviations_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_meters_device_id_abbreviations_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/meters/#{device_id}/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.MeterResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_meters_device_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.MeterResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_meters_device_id_get(connection, system_key, device_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/meters/#{device_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.MeterResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.DeviceResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_meters_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.DeviceResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_meters_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/meters")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
- :username (String.t): Get single user information by its username
## Returns
{:ok, ExVcom.Model.PictureResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_picture_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.PictureResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_picture_get(connection, system_key, opts \\ []) do
optional_params = %{
:username => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/picture")
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.PictureResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher).
- :device_ids (String.t): Comma separated deviceIds
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_power_plant_controllers_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_power_plant_controllers_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query,
:resolution => :query,
:deviceIds => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/power-plant-controllers/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_power_plant_controllers_device_id_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_power_plant_controllers_device_id_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url(
"/systems/#{system_key}/power-plant-controllers/#{device_id}/abbreviations/#{abbreviation_id}"
)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span between `from` and `to` varies depending on the `resolution` as listed below. | Resolution | Maximum time span | |-----------------|-------------------| | minute | 1 day | | interval | 31 days | | fifteen-minutes | 31 days | | thirty-minutes | 31 days | | hour | 31 days | | day | 60 days | | month | 1 year | | year | no limitation |
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher).
## Returns
{:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_power_plant_controllers_device_id_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_power_plant_controllers_device_id_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
device_id,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url(
"/systems/#{system_key}/power-plant-controllers/#{device_id}/abbreviations/#{abbreviation_id}/measurements"
)
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceMeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_power_plant_controllers_device_id_abbreviations_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_power_plant_controllers_device_id_abbreviations_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/power-plant-controllers/#{device_id}/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.PowerPlantControllerResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_power_plant_controllers_device_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.PowerPlantControllerResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_power_plant_controllers_device_id_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/power-plant-controllers/#{device_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.PowerPlantControllerResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.DeviceResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_power_plant_controllers_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.DeviceResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_power_plant_controllers_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/power-plant-controllers")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.ResponsibilitiesResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_responsibilities_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.ResponsibilitiesResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_responsibilities_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/responsibilities")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.ResponsibilitiesResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher)
- :device_ids (String.t): Comma separated deviceIds
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_sensors_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_sensors_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query,
:resolution => :query,
:deviceIds => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/sensors/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_sensors_device_id_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_sensors_device_id_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/sensors/#{device_id}/abbreviations/#{abbreviation_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span between `from` and `to` varies depending on the `resolution` as listed below. | Resolution | Maximum time span | |-----------------|-------------------| | minute | 1 day | | interval | 31 days | | fifteen-minutes | 31 days | | thirty-minutes | 31 days | | hour | 31 days | | day | 60 days | | month | 1 year | | year | no limitation |
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`.
- :resolution (String.t): Defaults to `interval`.
## Returns
{:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_sensors_device_id_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_sensors_device_id_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
device_id,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url(
"/systems/#{system_key}/sensors/#{device_id}/abbreviations/#{abbreviation_id}/measurements"
)
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceMeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_sensors_device_id_abbreviations_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_sensors_device_id_abbreviations_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/sensors/#{device_id}/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.SensorResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_sensors_device_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.SensorResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_sensors_device_id_get(connection, system_key, device_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/sensors/#{device_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.SensorResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.DeviceResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_sensors_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.DeviceResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_sensors_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/sensors")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`.
- :device_ids (String.t): Comma separated deviceIds
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_statuses_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_statuses_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query,
:resolution => :query,
:deviceIds => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/statuses/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_statuses_device_id_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_statuses_device_id_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/statuses/#{device_id}/abbreviations/#{abbreviation_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`.
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`.
- :resolution (String.t): Defaults to `interval`.
## Returns
{:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_statuses_device_id_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_statuses_device_id_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
device_id,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url(
"/systems/#{system_key}/statuses/#{device_id}/abbreviations/#{abbreviation_id}/measurements"
)
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceMeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_statuses_device_id_abbreviations_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_statuses_device_id_abbreviations_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/statuses/#{device_id}/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.StatusResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_statuses_device_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.StatusResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_statuses_device_id_get(connection, system_key, device_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/statuses/#{device_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.StatusResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.DeviceResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_statuses_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.DeviceResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_statuses_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/statuses")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher).
- :device_ids (String.t): Comma separated deviceIds
- :active_only (integer()): Export active strings only, defaults to `0`.
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_stringboxes_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_stringboxes_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query,
:resolution => :query,
:deviceIds => :query,
:activeOnly => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/stringboxes/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_stringboxes_device_id_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_stringboxes_device_id_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/stringboxes/#{device_id}/abbreviations/#{abbreviation_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`.
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`.
- :resolution (String.t): Defaults to `interval`.
## Returns
{:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_stringboxes_device_id_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_stringboxes_device_id_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
device_id,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url(
"/systems/#{system_key}/stringboxes/#{device_id}/abbreviations/#{abbreviation_id}/measurements"
)
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceMeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_stringboxes_device_id_abbreviations_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_stringboxes_device_id_abbreviations_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/stringboxes/#{device_id}/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.StringboxResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_stringboxes_device_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.StringboxResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_stringboxes_device_id_get(connection, system_key, device_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/stringboxes/#{device_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.StringboxResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.DeviceResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_stringboxes_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.DeviceResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_stringboxes_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/stringboxes")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TechnicalDataResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_technical_data_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.TechnicalDataResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_technical_data_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/technical-data")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.TechnicalDataResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`. The following query parameters are valid only if `format` is `csv`: - delimiter: `comma`ǀ`semicolon`ǀ`colon`ǀ`tab` The delimiter, defaults to `comma` - lineBreak: `LF`ǀ`CR`ǀ`CR/LF` The line breaks, defaults to `LF` - decimalPoint: `dot`ǀ`comma` The decimal point, defaults to `dot` - emptyPlaceholder: empty string by default, any text accepted The place holder for empty value - precision: accepts from 0 to 4 The decimal precision, defaults to `2`
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- from (DateTime.t):
- to (DateTime.t):
- opts (KeywordList): [optional] Optional parameters
- :format (String.t): Export format, defaults to `json`
- :abbreviations (String.t): Comma separated abbreviations
- :include_interval (integer()): Defaults to `0`. Only for `interval` resolution.
- :resolution (String.t): Defaults to `interval`. The option `minute` resolution is only supported by meteocontrol blue'Log XM / XC (Firmware 2.0 and higher)
- :device_ids (String.t): Comma separated deviceIds
## Returns
{:ok, map()} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_trackers_bulk_measurements_get(
Tesla.Env.client(),
String.t(),
DateTime.t(),
DateTime.t(),
keyword()
) :: {:ok, nil} | {:ok, Map.t()} | {:error, Tesla.Env.t()}
def systems_system_key_trackers_bulk_measurements_get(
connection,
system_key,
from,
to,
opts \\ []
) do
optional_params = %{
:format => :query,
:abbreviations => :query,
:includeInterval => :query,
:resolution => :query,
:deviceIds => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/trackers/bulk/measurements")
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_trackers_device_id_abbreviations_abbreviation_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_trackers_device_id_abbreviations_abbreviation_id_get(
connection,
system_key,
abbreviation_id,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/trackers/#{device_id}/abbreviations/#{abbreviation_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
The maximum time span is 24 hours between `from` and `to`.
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- abbreviation_id (String.t):
- from (DateTime.t):
- to (DateTime.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
- :include_interval (integer()): Defaults to `0`.
- :resolution (String.t): Defaults to `interval`.
## Returns
{:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_trackers_device_id_abbreviations_abbreviation_id_measurements_get(
Tesla.Env.client(),
String.t(),
String.t(),
DateTime.t(),
DateTime.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.DeviceMeasurementsAbbreviationsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_trackers_device_id_abbreviations_abbreviation_id_measurements_get(
connection,
system_key,
abbreviation_id,
from,
to,
device_id,
opts \\ []
) do
optional_params = %{
:includeInterval => :query,
:resolution => :query
}
%{}
|> method(:get)
|> url(
"/systems/#{system_key}/trackers/#{device_id}/abbreviations/#{abbreviation_id}/measurements"
)
|> add_param(:query, :from, from)
|> add_param(:query, :to, to)
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceMeasurementsAbbreviationsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.AbbreviationResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_trackers_device_id_abbreviations_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.AbbreviationResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_trackers_device_id_abbreviations_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/trackers/#{device_id}/abbreviations")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.AbbreviationResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.SensorResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_trackers_device_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.SensorResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_trackers_device_id_get(connection, system_key, device_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/trackers/#{device_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.SensorResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.DeviceResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_trackers_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.DeviceResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_trackers_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/trackers")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.UserResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_users_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.UserResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_users_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/users")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.UserResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- user_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.UserDetailsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_users_user_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.UserDetailsResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_users_user_id_get(connection, system_key, user_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/users/#{user_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.UserDetailsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.VirtualMeterDetailsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_virtual_meters_device_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.VirtualMeterDetailsResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_virtual_meters_device_id_get(
connection,
system_key,
device_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/virtual-meters/#{device_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.VirtualMeterDetailsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
If no time range is given the endpoint returns the latest reading.
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- device_id (String.t):
- opts (KeywordList): [optional] Optional parameters
- :from (DateTime.t):
- :to (DateTime.t):
- :type (String.t): Defaults to `all`.
## Returns
{:ok, ExVcom.Model.VirtualMeterReadingResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_virtual_meters_device_id_readings_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.VirtualMeterReadingResponse.t()}
| {:error, Tesla.Env.t()}
def systems_system_key_virtual_meters_device_id_readings_get(
connection,
system_key,
device_id,
opts \\ []
) do
optional_params = %{
:from => :query,
:to => :query,
:type => :query
}
%{}
|> method(:get)
|> url("/systems/#{system_key}/virtual-meters/#{device_id}/readings")
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.VirtualMeterReadingResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- system_key (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.DeviceResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec systems_system_key_virtual_meters_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.DeviceResponse.t()} | {:error, Tesla.Env.t()}
def systems_system_key_virtual_meters_get(connection, system_key, _opts \\ []) do
%{}
|> method(:get)
|> url("/systems/#{system_key}/virtual-meters")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.DeviceResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketCausesResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_causes_get(Tesla.Env.client(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.TicketCausesResponse.t()} | {:error, Tesla.Env.t()}
def tickets_causes_get(connection, _opts \\ []) do
%{}
|> method(:get)
|> url("/tickets/causes")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.TicketCausesResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
Returns all tickets.
## Parameters
- connection (ExVcom.Connection): Connection to server
- opts (KeywordList): [optional] Optional parameters
- :last_changed_at_left_square_bracketfrom_right_square_bracket (DateTime.t):
- :last_changed_at_left_square_bracketto_right_square_bracket (DateTime.t):
- :created_at_left_square_bracketfrom_right_square_bracket (DateTime.t):
- :created_at_left_square_bracketto_right_square_bracket (DateTime.t):
- :rectified_at_left_square_bracketfrom_right_square_bracket (DateTime.t):
- :rectified_at_left_square_bracketto_right_square_bracket (DateTime.t):
- :include_in_reports (String.t): Can contain comma delimited report types
- :status (String.t):
- :severity (String.t): Can contain comma delimited severity types
- :priority (String.t): Can contain comma delimited priority types
- :assignee (String.t): The username of the person being assigned to the ticket, it can contain comma delimited names.
- :system_key (String.t): can contain comma delimited system keys
## Returns
{:ok, ExVcom.Model.TicketsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_get(Tesla.Env.client(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.TicketsResponse.t()} | {:error, Tesla.Env.t()}
def tickets_get(connection, opts \\ []) do
optional_params = %{
:"lastChangedAt[from]" => :query,
:"lastChangedAt[to]" => :query,
:"createdAt[from]" => :query,
:"createdAt[to]" => :query,
:"rectifiedAt[from]" => :query,
:"rectifiedAt[to]" => :query,
:includeInReports => :query,
:status => :query,
:severity => :query,
:priority => :query,
:assignee => :query,
:systemKey => :query
}
%{}
|> method(:get)
|> url("/tickets")
|> add_optional_params(optional_params, opts)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.TicketsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
Create a ticket
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_update_payload (TicketUpdatePayload):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketCreateResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_post(Tesla.Env.client(), ExVcom.Model.TicketUpdatePayload.t(), keyword()) ::
{:ok, ExVcom.Model.TicketCreateResponse.t()} | {:error, Tesla.Env.t()}
def tickets_post(connection, ticket_update_payload, _opts \\ []) do
%{}
|> method(:post)
|> url("/tickets")
|> add_param(:body, :body, ticket_update_payload)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{201, %ExVcom.Model.TicketCreateResponse{}}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- attachment_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketAttachmentDetailsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_attachments_attachment_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) ::
{:ok, nil}
| {:ok, ExVcom.Model.TicketAttachmentDetailsResponse.t()}
| {:error, Tesla.Env.t()}
def tickets_ticket_id_attachments_attachment_id_get(
connection,
ticket_id,
attachment_id,
_opts \\ []
) do
%{}
|> method(:get)
|> url("/tickets/#{ticket_id}/attachments/#{attachment_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.TicketAttachmentDetailsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
Get all attachments
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketAttachmentsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_attachments_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.TicketAttachmentsResponse.t()} | {:error, Tesla.Env.t()}
def tickets_ticket_id_attachments_get(connection, ticket_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/tickets/#{ticket_id}/attachments")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.TicketAttachmentsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
Create an attachment
Please note there’s a limit of 5 attachments per ticket.
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- ticket_attachment_create_payload (TicketAttachmentCreatePayload):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketAttachmentCreateResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_attachments_post(
Tesla.Env.client(),
String.t(),
ExVcom.Model.TicketAttachmentCreatePayload.t(),
keyword()
) :: {:ok, ExVcom.Model.TicketAttachmentCreateResponse.t()} | {:error, Tesla.Env.t()}
def tickets_ticket_id_attachments_post(
connection,
ticket_id,
ticket_attachment_create_payload,
_opts \\ []
) do
%{}
|> method(:post)
|> url("/tickets/#{ticket_id}/attachments")
|> add_param(:body, :body, ticket_attachment_create_payload)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{201, %ExVcom.Model.TicketAttachmentCreateResponse{}}
])
end
@doc """
Delete a comment
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- comment_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, nil} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_comments_comment_id_delete(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}
def tickets_ticket_id_comments_comment_id_delete(connection, ticket_id, comment_id, _opts \\ []) do
%{}
|> method(:delete)
|> url("/tickets/#{ticket_id}/comments/#{comment_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{204, false}
])
end
@doc """
Get single comment
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- comment_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketCommentResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_comments_comment_id_get(
Tesla.Env.client(),
String.t(),
String.t(),
keyword()
) :: {:ok, nil} | {:ok, ExVcom.Model.TicketCommentResponse.t()} | {:error, Tesla.Env.t()}
def tickets_ticket_id_comments_comment_id_get(connection, ticket_id, comment_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/tickets/#{ticket_id}/comments/#{comment_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.TicketCommentResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
Update a comment
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- comment_id (String.t):
- ticket_comment_create_payload (TicketCommentCreatePayload):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, nil} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_comments_comment_id_patch(
Tesla.Env.client(),
String.t(),
String.t(),
ExVcom.Model.TicketCommentCreatePayload.t(),
keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}
def tickets_ticket_id_comments_comment_id_patch(
connection,
ticket_id,
comment_id,
ticket_comment_create_payload,
_opts \\ []
) do
%{}
|> method(:patch)
|> url("/tickets/#{ticket_id}/comments/#{comment_id}")
|> add_param(:body, :body, ticket_comment_create_payload)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{204, false}
])
end
@doc """
Get all comments
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketCommentsResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_comments_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.TicketCommentsResponse.t()} | {:error, Tesla.Env.t()}
def tickets_ticket_id_comments_get(connection, ticket_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/tickets/#{ticket_id}/comments")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.TicketCommentsResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
Create a comment
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- ticket_comment_create_payload (TicketCommentCreatePayload):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketCommentCreateResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_comments_post(
Tesla.Env.client(),
String.t(),
ExVcom.Model.TicketCommentCreatePayload.t(),
keyword()
) :: {:ok, ExVcom.Model.TicketCommentCreateResponse.t()} | {:error, Tesla.Env.t()}
def tickets_ticket_id_comments_post(
connection,
ticket_id,
ticket_comment_create_payload,
_opts \\ []
) do
%{}
|> method(:post)
|> url("/tickets/#{ticket_id}/comments")
|> add_param(:body, :body, ticket_comment_create_payload)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{201, %ExVcom.Model.TicketCommentCreateResponse{}}
])
end
@doc """
Delete a ticket
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, nil} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_delete(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:error, Tesla.Env.t()}
def tickets_ticket_id_delete(connection, ticket_id, _opts \\ []) do
%{}
|> method(:delete)
|> url("/tickets/#{ticket_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{204, false},
{403, false}
])
end
@doc """
Returns detailed information about a single ticket.
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.TicketResponse.t()} | {:error, Tesla.Env.t()}
def tickets_ticket_id_get(connection, ticket_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/tickets/#{ticket_id}")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.TicketResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, ExVcom.Model.TicketHistoryResponse.t} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_histories_get(Tesla.Env.client(), String.t(), keyword()) ::
{:ok, nil} | {:ok, ExVcom.Model.TicketHistoryResponse.t()} | {:error, Tesla.Env.t()}
def tickets_ticket_id_histories_get(connection, ticket_id, _opts \\ []) do
%{}
|> method(:get)
|> url("/tickets/#{ticket_id}/histories")
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{200, %ExVcom.Model.TicketHistoryResponse{}},
{400, false},
{401, false},
{403, false},
{404, false},
{429, false},
{500, false}
])
end
@doc """
Update a ticket
## Parameters
- connection (ExVcom.Connection): Connection to server
- ticket_id (String.t):
- ticket_update_payload (TicketUpdatePayload):
- opts (KeywordList): [optional] Optional parameters
## Returns
{:ok, nil} on success
{:error, Tesla.Env.t} on failure
"""
@spec tickets_ticket_id_patch(
Tesla.Env.client(),
String.t(),
ExVcom.Model.TicketUpdatePayload.t(),
keyword()
) :: {:ok, nil} | {:error, Tesla.Env.t()}
def tickets_ticket_id_patch(connection, ticket_id, ticket_update_payload, _opts \\ []) do
%{}
|> method(:patch)
|> url("/tickets/#{ticket_id}")
|> add_param(:body, :body, ticket_update_payload)
|> Enum.into([])
|> (&Connection.request(connection, &1)).()
|> evaluate_response([
{204, false}
])
end
end
