teslatte 0.1.15

A command line tool and Rust crate for querying the Tesla API.
Documentation 
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

use crate::vehicles::{
    Endpoints, GetVehicleData, SetChargeLimit, SetChargingAmps, SetScheduledCharging,
    SetScheduledDeparture, SetTemperatures,
};
use crate::{OwnerApi, VehicleApi, VehicleId};
use clap::{Args, Subcommand};

#[derive(Debug, Subcommand)]
pub enum VehicleCommand {
    /// Get vehicle data.
    VehicleData(Endpoints),

    /// Open the charge port door or unlocks the cable.
    ChargePortDoorOpen,

    /// For vehicles with a motorized charge port, this closes it.
    ChargePortDoorClose,

    /// Set charge limit.
    SetChargeLimit(SetChargeLimit),

    /// Set charge amps.
    SetChargingAmps(SetChargingAmps),

    /// Set the charge limit to the standard %.
    ChargeStandard,

    /// Set the charge limit to the maximum %.
    ChargeMaxRange,

    /// Start charging.
    ChargeStart,

    /// Stop charging.
    ChargeStop,

    /// Set scheduled charging.
    SetScheduledCharging(SetScheduledCharging),

    /// Set scheduled departure.
    SetScheduledDeparture(SetScheduledDeparture),

    /// Honk!
    HonkHorn,

    /// Flash the lights.
    FlashLights,

    /// Enable the HVAC
    EnableHvac,

    /// Disable the HVAC
    DisableHvac,

    /// Set the temperature for the HVAC
    HvacTemperature(SetTemperatures),

    /// Door unlock
    DoorUnlock,

    /// Door lock
    DoorLock,

    /// For keyless driving
    RemoteStartDrive,
}

#[derive(Debug, Args)]
pub struct VehicleArgs {
    pub id: VehicleId,

    #[clap(subcommand)]
    pub command: VehicleCommand,
}

impl VehicleArgs {
    pub async fn run(self, api: &OwnerApi) -> miette::Result<()> {
        match self.command {
            VehicleCommand::VehicleData(endpoints) => {
                let get_vehicle_data = GetVehicleData::new_with_endpoints(self.id, endpoints);
                api.vehicle_data(&get_vehicle_data).await?;
            }
            VehicleCommand::SetChargeLimit(limit) => {
                api.set_charge_limit(&self.id, &limit).await?;
            }
            VehicleCommand::SetChargingAmps(charging_amps) => {
                api.set_charging_amps(&self.id, &charging_amps).await?;
            }
            VehicleCommand::ChargeStart => {
                api.charge_start(&self.id).await?;
            }
            VehicleCommand::ChargeStop => {
                api.charge_stop(&self.id).await?;
            }
            VehicleCommand::ChargePortDoorOpen => {
                api.charge_port_door_open(&self.id).await?;
            }
            VehicleCommand::ChargePortDoorClose => {
                api.charge_port_door_close(&self.id).await?;
            }
            VehicleCommand::ChargeStandard => {
                api.charge_standard(&self.id).await?;
            }
            VehicleCommand::ChargeMaxRange => {
                api.charge_max_range(&self.id).await?;
            }
            VehicleCommand::SetScheduledCharging(charging) => {
                api.set_scheduled_charging(&self.id, &charging).await?;
            }
            VehicleCommand::SetScheduledDeparture(departure) => {
                api.set_scheduled_departure(&self.id, &departure).await?;
            }
            VehicleCommand::HonkHorn => {
                api.honk_horn(&self.id).await?;
            }
            VehicleCommand::FlashLights => {
                api.flash_lights(&self.id).await?;
            }
            VehicleCommand::EnableHvac => {
                api.auto_conditioning_start(&self.id).await?;
            }
            VehicleCommand::DisableHvac => {
                api.auto_conditioning_stop(&self.id).await?;
            }
            VehicleCommand::HvacTemperature(temps) => {
                api.set_temps(&self.id, &temps).await?;
            }
            VehicleCommand::DoorUnlock => {
                api.door_unlock(&self.id).await?;
            }
            VehicleCommand::DoorLock => {
                api.door_lock(&self.id).await?;
            }
            VehicleCommand::RemoteStartDrive => {
                api.remote_start_drive(&self.id).await?;
            }
        }
        Ok(())
    }
}