isideload 0.2.21

Sideload iOS/iPadOS applications
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

use crate::dev::{
    app_ids::AppId,
    developer_session::DeveloperSession,
    device_type::{DeveloperDeviceType, dev_url},
    teams::DeveloperTeam,
};
use plist_macro::plist;
use rootcause::prelude::*;
use serde::Deserialize;
use tracing::info;

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AppGroup {
    pub name: Option<String>,
    pub identifier: String,
    pub application_group: String,
}

#[async_trait::async_trait]
pub trait AppGroupsApi {
    fn developer_session(&mut self) -> &mut DeveloperSession;

    async fn list_app_groups(
        &mut self,
        team: &DeveloperTeam,
        device_type: impl Into<Option<DeveloperDeviceType>> + Send,
    ) -> Result<Vec<AppGroup>, Report> {
        let body = plist!(dict {
            "teamId": &team.team_id,
        });

        let app_groups: Vec<AppGroup> = self
            .developer_session()
            .send_dev_request(
                &dev_url("listApplicationGroups", device_type),
                body,
                "applicationGroupList",
            )
            .await
            .context("Failed to list developer app groups")?;

        Ok(app_groups)
    }

    async fn add_app_group(
        &mut self,
        team: &DeveloperTeam,
        name: &str,
        identifier: &str,
        device_type: impl Into<Option<DeveloperDeviceType>> + Send,
    ) -> Result<AppGroup, Report> {
        let body = plist!(dict {
            "teamId": &team.team_id,
            "name": name,
            "identifier": identifier,
        });

        let app_group: AppGroup = self
            .developer_session()
            .send_dev_request(
                &dev_url("addApplicationGroup", device_type),
                body,
                "applicationGroup",
            )
            .await
            .context("Failed to add developer app group")?;

        Ok(app_group)
    }

    async fn assign_app_group(
        &mut self,
        team: &DeveloperTeam,
        app_group: &AppGroup,
        app_id: &AppId,
        device_type: impl Into<Option<DeveloperDeviceType>> + Send,
    ) -> Result<(), Report> {
        let body = plist!(dict {
            "teamId": &team.team_id,
            "applicationGroups": &app_group.application_group,
            "appIdId": &app_id.app_id_id,
        });

        self.developer_session()
            .send_dev_request_no_response(
                &dev_url("assignApplicationGroupToAppId", device_type),
                body,
            )
            .await
            .context("Failed to assign developer app group")?;

        Ok(())
    }

    async fn ensure_app_group(
        &mut self,
        team: &DeveloperTeam,
        name: &str,
        identifier: &str,
        device_type: impl Into<Option<DeveloperDeviceType>> + Send,
    ) -> Result<AppGroup, Report> {
        let device_type = device_type.into();
        let groups = self.list_app_groups(team, device_type.clone()).await?;
        let matching_group = groups.iter().find(|g| g.identifier == identifier);

        if let Some(group) = matching_group {
            Ok(group.clone())
        } else {
            info!("Adding application group");
            let group = self
                .add_app_group(team, name, identifier, device_type)
                .await?;
            Ok(group)
        }
    }
}

impl AppGroupsApi for DeveloperSession {
    fn developer_session(&mut self) -> &mut DeveloperSession {
        self
    }
}