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

//Anything related to PUT requests for Teams and it's variations goes here.
use super::{TeamInvitation, TeamMember};

use crate::framework::endpoint::{HerokuEndpoint, Method};

/// Team Invitation Create
///
/// Create Team Invitation
///
/// [See Heroku documentation for more information about this endpoint](https://devcenter.heroku.com/articles/platform-api-reference#team-invitation-create)
pub struct TeamInvitationCreate<'a> {
    /// unique team identifier
    pub team_id: &'a str,
    /// parameters to pass to Heroku
    pub params: TeamInvitationCreateParams<'a>,
}

impl<'a> TeamInvitationCreate<'a> {
    pub fn new(
        team_id: &'a str,
        email: &'a str,
        role: Option<&'a str>,
    ) -> TeamInvitationCreate<'a> {
        TeamInvitationCreate {
            team_id,
            params: TeamInvitationCreateParams { email, role },
        }
    }
}

/// Create a new team invitation with parameters
///
/// role parameter is nullable, meaning, if you pass (None), it will be sent as `null` to the Heroku API
///
/// [See Heroku documentation for more information about these paramters](https://devcenter.heroku.com/articles/platform-api-reference#team-invitation-create-required-parameters)
#[derive(Serialize, Clone, Debug)]
pub struct TeamInvitationCreateParams<'a> {
    /// unique email address
    pub email: &'a str,
    /// Even though marked with `Option`, this parameter is NOT optional.
    /// role in the team
    /// one of:"admin" or "collaborator" or "member" or "owner" or null. [Nullable]
    pub role: Option<&'a str>,
}

impl<'a> HerokuEndpoint<TeamInvitation, (), TeamInvitationCreateParams<'a>>
    for TeamInvitationCreate<'a>
{
    fn method(&self) -> Method {
        Method::Put
    }
    fn path(&self) -> String {
        format!("teams/{}/invitations", self.team_id)
    }
    fn body(&self) -> Option<TeamInvitationCreateParams<'a>> {
        Some(self.params.clone())
    }
}

/// Team Member Create or Update
///
/// Create a new team member, or update their role.
///
/// [See Heroku documentation for more information about this endpoint](https://devcenter.heroku.com/articles/platform-api-reference#team-member-create-or-update)
pub struct TeamMemberCreateorUpdate<'a> {
    /// unique team identifier
    pub team_id: &'a str,
    /// parameters to pass to Heroku
    pub params: TeamMemberCreateorUpdateParams<'a>,
}

impl<'a> TeamMemberCreateorUpdate<'a> {
    /// required and optional parameters
    pub fn new(
        team_id: &'a str,
        email: &'a str,
        role: &'a str,
        federated: Option<bool>,
    ) -> TeamMemberCreateorUpdate<'a> {
        TeamMemberCreateorUpdate {
            team_id,
            params: TeamMemberCreateorUpdateParams {
                email,
                role,
                federated,
            },
        }
    }
    /// Only required parameters passed
    pub fn create(team_id: &'a str, email: &'a str, role: &'a str) -> TeamMemberCreateorUpdate<'a> {
        TeamMemberCreateorUpdate {
            team_id,
            params: TeamMemberCreateorUpdateParams {
                email: email,
                role: role,
                federated: None,
            },
        }
    }
}

/// Create or update  team member with parameters
///
/// [See Heroku documentation for more information about these paramters](https://devcenter.heroku.com/articles/platform-api-reference#team-member-create-or-update-required-parameters)
#[serde_with::skip_serializing_none]
#[derive(Serialize, Clone, Debug)]
pub struct TeamMemberCreateorUpdateParams<'a> {
    /// unique email address
    pub email: &'a str,
    /// Even though marked with `Option`, this parameter is NOT optional.
    /// role in the team
    /// one of:"admin" or "collaborator" or "member" or "owner" or null
    pub role: &'a str,
    /// whether the user is federated and belongs to an Identity Provider
    pub federated: Option<bool>,
}

impl<'a> HerokuEndpoint<TeamMember, (), TeamMemberCreateorUpdateParams<'a>>
    for TeamMemberCreateorUpdate<'a>
{
    fn method(&self) -> Method {
        Method::Put
    }
    fn path(&self) -> String {
        format!("teams/{}/members", self.team_id)
    }
    fn body(&self) -> Option<TeamMemberCreateorUpdateParams<'a>> {
        Some(self.params.clone())
    }
}