aboutsummaryrefslogtreecommitdiff
path: root/shared/src/commonMain/kotlin/mx/trackermap/TrackerMap/client/apis/CommandsApi.kt
blob: f00bc93c3704fe03f001c4461134f39b7f3e6b3f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
/**
 * Traccar
 * Traccar GPS tracking server API documentation. To use the API you need to have a server instance. For testing purposes you can use one of free [demo servers](https://www.traccar.org/demo-server/). For production use you can install your own server or get a [subscription service](https://www.traccar.org/product/tracking-server/).
 *
 * OpenAPI spec version: 4.14
 * Contact: support@traccar.org
 *
 * NOTE: This class is auto generated by the swagger code generator program.
 * https://github.com/swagger-api/swagger-codegen.git
 * Do not edit the class manually.
 */
package mx.trackermap.TrackerMap.client.apis

import mx.trackermap.TrackerMap.client.models.Command
import mx.trackermap.TrackerMap.client.models.CommandType

import mx.trackermap.TrackerMap.client.infrastructure.*

class CommandsApi : ApiClient() {

    /**
     * Fetch a list of Saved Commands
     * Without params, it returns a list of Saved Commands the user has access to
     * @param all Can only be used by admins or managers to fetch all entities (optional)
     * @param userId Standard users can use this only with their own _userId_ (optional)
     * @param deviceId Standard users can use this only with _deviceId_s, they have access to (optional)
     * @param groupId Standard users can use this only with _groupId_s, they have access to (optional)
     * @param refresh  (optional)
     * @return kotlin.Array<Command>
     */
    @Suppress("UNCHECKED_CAST")
    suspend fun commandsGet(all: Boolean? = null, userId: Int? = null, deviceId: Int? = null, groupId: Int? = null, refresh: Boolean? = null): Array<Command> {
        val query: MutableMap<String, List<String>> = mutableMapOf()
        all?.let { query["all"] = listOf("$it") }
        userId?.let { query["userId"] = listOf("$it") }
        deviceId?.let { query["deviceId"] = listOf("$it") }
        groupId?.let { query["groupId"] = listOf("$it") }
        refresh?.let { query["refresh"] = listOf("$it") }
        val localVariableQuery: MultiValueMap = query

        val localVariableConfig = RequestConfig(
                RequestMethod.GET,
                "/commands", query = localVariableQuery
        )
        val response = request<Array<Command>>(
                localVariableConfig
        )

        return when (response.responseType) {
            ResponseType.Success -> (response as Success<*>).data as Array<Command>
            ResponseType.Informational -> TODO()
            ResponseType.Redirection -> TODO()
            ResponseType.ClientError -> throw ClientException((response as ClientError<*>).body as? String ?: "Client error")
            ResponseType.ServerError -> throw ServerException((response as ServerError<*>).message ?: "Server error")
        }
    }
    /**
     * Delete a Saved Command
     * 
     * @param id  
     * @return void
     */
    suspend fun commandsIdDelete(id: Int) {
        
        val localVariableConfig = RequestConfig(
                RequestMethod.DELETE,
                "/commands/{id}".replace("{" + "id" + "}", "$id")
        )
        val response = request<Any?>(
                localVariableConfig
        )

        return when (response.responseType) {
            ResponseType.Success -> Unit
            ResponseType.Informational -> TODO()
            ResponseType.Redirection -> TODO()
            ResponseType.ClientError -> throw ClientException((response as ClientError<*>).body as? String ?: "Client error")
            ResponseType.ServerError -> throw ServerException((response as ServerError<*>).message ?: "Server error")
        }
    }
    /**
     * Update a Saved Command
     * 
     * @param body  
     * @param id  
     * @return Command
     */
    @Suppress("UNCHECKED_CAST")
    suspend fun commandsIdPut(body: Command, id: Int): Command {
        val localVariableBody: Any = body
        
        val localVariableConfig = RequestConfig(
                RequestMethod.PUT,
                "/commands/{id}".replace("{" + "id" + "}", "$id")
        )
        val response = request<Command>(
                localVariableConfig, localVariableBody
        )

        return when (response.responseType) {
            ResponseType.Success -> (response as Success<*>).data as Command
            ResponseType.Informational -> TODO()
            ResponseType.Redirection -> TODO()
            ResponseType.ClientError -> throw ClientException((response as ClientError<*>).body as? String ?: "Client error")
            ResponseType.ServerError -> throw ServerException((response as ServerError<*>).message ?: "Server error")
        }
    }
    /**
     * Create a Saved Command
     * 
     * @param body  
     * @return Command
     */
    @Suppress("UNCHECKED_CAST")
    suspend fun commandsPost(body: Command): Command {
        val localVariableBody: Any = body
        
        val localVariableConfig = RequestConfig(
                RequestMethod.POST,
                "/commands"
        )
        val response = request<Command>(
                localVariableConfig, localVariableBody
        )

        return when (response.responseType) {
            ResponseType.Success -> (response as Success<*>).data as Command
            ResponseType.Informational -> TODO()
            ResponseType.Redirection -> TODO()
            ResponseType.ClientError -> throw ClientException((response as ClientError<*>).body as? String ?: "Client error")
            ResponseType.ServerError -> throw ServerException((response as ServerError<*>).message ?: "Server error")
        }
    }
    /**
     * Fetch a list of Saved Commands supported by Device at the moment
     * Return a list of saved commands linked to Device and its groups, filtered by current Device protocol support
     * @param deviceId Standard users can use this only with _deviceId_s, they have access to (optional)
     * @return kotlin.Array<Command>
     */
    @Suppress("UNCHECKED_CAST")
    suspend fun commandsSendGet(deviceId: Int? = null): Array<Command> {
        val localVariableQuery: MultiValueMap = mapOf("deviceId" to listOf("$deviceId"))
        val localVariableConfig = RequestConfig(
                RequestMethod.GET,
                "/commands/send", query = localVariableQuery
        )
        val response = request<Array<Command>>(
                localVariableConfig
        )

        return when (response.responseType) {
            ResponseType.Success -> (response as Success<*>).data as Array<Command>
            ResponseType.Informational -> TODO()
            ResponseType.Redirection -> TODO()
            ResponseType.ClientError -> throw ClientException((response as ClientError<*>).body as? String ?: "Client error")
            ResponseType.ServerError -> throw ServerException((response as ServerError<*>).message ?: "Server error")
        }
    }
    /**
     * Dispatch commands to device
     * Dispatch a new command or Saved Command if _body.id_ set
     * @param body  
     * @return Command
     */
    @Suppress("UNCHECKED_CAST")
    suspend fun commandsSendPost(body: Command): Command {
        val localVariableBody: Any = body
        
        val localVariableConfig = RequestConfig(
                RequestMethod.POST,
                "/commands/send"
        )
        val response = request<Command>(
                localVariableConfig, localVariableBody
        )

        return when (response.responseType) {
            ResponseType.Success -> (response as Success<*>).data as Command
            ResponseType.Informational -> TODO()
            ResponseType.Redirection -> TODO()
            ResponseType.ClientError -> throw ClientException((response as ClientError<*>).body as? String ?: "Client error")
            ResponseType.ServerError -> throw ServerException((response as ServerError<*>).message ?: "Server error")
        }
    }
    /**
     * Fetch a list of available Commands for the Device or all possible Commands if Device ommited
     * 
     * @param deviceId Internal device identifier. Only works if device has already reported some locations (optional)
     * @param protocol Protocol name. Can be used instead of device id (optional)
     * @param textChannel When &#x60;true&#x60; return SMS commands. If not specified or &#x60;false&#x60; return data commands (optional)
     * @return kotlin.Array<CommandType>
     */
    @Suppress("UNCHECKED_CAST")
    suspend fun commandsTypesGet(deviceId: Int? = null, protocol: String? = null, textChannel: Boolean? = null): Array<CommandType> {
        val localVariableQuery: MultiValueMap = mapOf("deviceId" to listOf("$deviceId"), "protocol" to listOf("$protocol"), "textChannel" to listOf("$textChannel"))
        val localVariableConfig = RequestConfig(
                RequestMethod.GET,
                "/commands/types", query = localVariableQuery
        )
        val response = request<Array<CommandType>>(
                localVariableConfig
        )

        return when (response.responseType) {
            ResponseType.Success -> (response as Success<*>).data as Array<CommandType>
            ResponseType.Informational -> TODO()
            ResponseType.Redirection -> TODO()
            ResponseType.ClientError -> throw ClientException((response as ClientError<*>).body as? String ?: "Client error")
            ResponseType.ServerError -> throw ServerException((response as ServerError<*>).message ?: "Server error")
        }
    }
}