github.com/gravitational/teleport/api@v0.0.0-20240507183017-3110591cbafc/client/okta/okta.go (about) 1 // Copyright 2023 Gravitational, Inc. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 package okta 16 17 import ( 18 "context" 19 "time" 20 21 "github.com/gravitational/trace" 22 "google.golang.org/protobuf/types/known/durationpb" 23 24 oktapb "github.com/gravitational/teleport/api/gen/proto/go/teleport/okta/v1" 25 "github.com/gravitational/teleport/api/types" 26 ) 27 28 // Client is an Okta client that conforms to the following lib/services interfaces: 29 // * services.OktaImportRules 30 // * services.OktaAssignments 31 type Client struct { 32 grpcClient oktapb.OktaServiceClient 33 } 34 35 // NewClient creates a new Okta client. 36 func NewClient(grpcClient oktapb.OktaServiceClient) *Client { 37 return &Client{ 38 grpcClient: grpcClient, 39 } 40 } 41 42 // ListOktaImportRules returns a paginated list of all Okta import rule resources. 43 func (c *Client) ListOktaImportRules(ctx context.Context, pageSize int, pageToken string) ([]types.OktaImportRule, string, error) { 44 resp, err := c.grpcClient.ListOktaImportRules(ctx, &oktapb.ListOktaImportRulesRequest{ 45 PageSize: int32(pageSize), 46 PageToken: pageToken, 47 }) 48 if err != nil { 49 return nil, "", trace.Wrap(err) 50 } 51 52 importRules := make([]types.OktaImportRule, len(resp.ImportRules)) 53 for i, importRule := range resp.ImportRules { 54 importRules[i] = importRule 55 } 56 57 return importRules, resp.NextPageToken, nil 58 } 59 60 // GetOktaImportRule returns the specified Okta import rule resources. 61 func (c *Client) GetOktaImportRule(ctx context.Context, name string) (types.OktaImportRule, error) { 62 resp, err := c.grpcClient.GetOktaImportRule(ctx, &oktapb.GetOktaImportRuleRequest{ 63 Name: name, 64 }) 65 return resp, trace.Wrap(err) 66 } 67 68 // CreateOktaImportRule creates a new Okta import rule resource. 69 func (c *Client) CreateOktaImportRule(ctx context.Context, importRule types.OktaImportRule) (types.OktaImportRule, error) { 70 importRuleV1, ok := importRule.(*types.OktaImportRuleV1) 71 if !ok { 72 return nil, trace.BadParameter("import rule expected to be OktaImportRuleV1, got %T", importRule) 73 } 74 resp, err := c.grpcClient.CreateOktaImportRule(ctx, &oktapb.CreateOktaImportRuleRequest{ 75 ImportRule: importRuleV1, 76 }) 77 return resp, trace.Wrap(err) 78 } 79 80 // UpdateOktaImportRule updates an existing Okta import rule resource. 81 func (c *Client) UpdateOktaImportRule(ctx context.Context, importRule types.OktaImportRule) (types.OktaImportRule, error) { 82 importRuleV1, ok := importRule.(*types.OktaImportRuleV1) 83 if !ok { 84 return nil, trace.BadParameter("import rule expected to be OktaImportRuleV1, got %T", importRule) 85 } 86 resp, err := c.grpcClient.UpdateOktaImportRule(ctx, &oktapb.UpdateOktaImportRuleRequest{ 87 ImportRule: importRuleV1, 88 }) 89 return resp, trace.Wrap(err) 90 } 91 92 // DeleteOktaImportRule removes the specified Okta import rule resource. 93 func (c *Client) DeleteOktaImportRule(ctx context.Context, name string) error { 94 _, err := c.grpcClient.DeleteOktaImportRule(ctx, &oktapb.DeleteOktaImportRuleRequest{ 95 Name: name, 96 }) 97 return trace.Wrap(err) 98 } 99 100 // DeleteAllOktaImportRules removes all Okta import rules. 101 func (c *Client) DeleteAllOktaImportRules(ctx context.Context) error { 102 _, err := c.grpcClient.DeleteAllOktaImportRules(ctx, &oktapb.DeleteAllOktaImportRulesRequest{}) 103 return trace.Wrap(err) 104 } 105 106 // ListOktaAssignments returns a paginated list of all Okta assignment resources. 107 func (c *Client) ListOktaAssignments(ctx context.Context, pageSize int, pageToken string) ([]types.OktaAssignment, string, error) { 108 resp, err := c.grpcClient.ListOktaAssignments(ctx, &oktapb.ListOktaAssignmentsRequest{ 109 PageSize: int32(pageSize), 110 PageToken: pageToken, 111 }) 112 if err != nil { 113 return nil, "", trace.Wrap(err) 114 } 115 116 assignments := make([]types.OktaAssignment, len(resp.Assignments)) 117 for i, assignment := range resp.Assignments { 118 assignments[i] = assignment 119 } 120 121 return assignments, resp.NextPageToken, nil 122 } 123 124 // GetOktaAssignmentreturns the specified Okta assignment resources. 125 func (c *Client) GetOktaAssignment(ctx context.Context, name string) (types.OktaAssignment, error) { 126 resp, err := c.grpcClient.GetOktaAssignment(ctx, &oktapb.GetOktaAssignmentRequest{ 127 Name: name, 128 }) 129 return resp, trace.Wrap(err) 130 } 131 132 // CreateOktaAssignmentcreates a new Okta assignment resource. 133 func (c *Client) CreateOktaAssignment(ctx context.Context, assignment types.OktaAssignment) (types.OktaAssignment, error) { 134 assignmentV1, ok := assignment.(*types.OktaAssignmentV1) 135 if !ok { 136 return nil, trace.BadParameter("import rule expected to be OktaAssignmentV1, got %T", assignment) 137 } 138 resp, err := c.grpcClient.CreateOktaAssignment(ctx, &oktapb.CreateOktaAssignmentRequest{ 139 Assignment: assignmentV1, 140 }) 141 return resp, trace.Wrap(err) 142 } 143 144 // UpdateOktaAssignmentupdates an existing Okta assignment resource. 145 func (c *Client) UpdateOktaAssignment(ctx context.Context, assignment types.OktaAssignment) (types.OktaAssignment, error) { 146 assignmentV1, ok := assignment.(*types.OktaAssignmentV1) 147 if !ok { 148 return nil, trace.BadParameter("import rule expected to be OktaAssignmentV1, got %T", assignment) 149 } 150 resp, err := c.grpcClient.UpdateOktaAssignment(ctx, &oktapb.UpdateOktaAssignmentRequest{ 151 Assignment: assignmentV1, 152 }) 153 return resp, trace.Wrap(err) 154 } 155 156 // UpdateOktaAssignmentStatus will update the status for an Okta assignment if the given time has passed 157 // since the last transition. 158 func (c *Client) UpdateOktaAssignmentStatus(ctx context.Context, name, status string, timeHasPassed time.Duration) error { 159 _, err := c.grpcClient.UpdateOktaAssignmentStatus(ctx, &oktapb.UpdateOktaAssignmentStatusRequest{ 160 Name: name, 161 Status: types.OktaAssignmentStatusToProto(status), 162 TimeHasPassed: durationpb.New(timeHasPassed), 163 }) 164 return trace.Wrap(err) 165 } 166 167 // DeleteOktaAssignmentremoves the specified Okta assignment resource. 168 func (c *Client) DeleteOktaAssignment(ctx context.Context, name string) error { 169 _, err := c.grpcClient.DeleteOktaAssignment(ctx, &oktapb.DeleteOktaAssignmentRequest{ 170 Name: name, 171 }) 172 return trace.Wrap(err) 173 } 174 175 // DeleteAllOktaAssignments removes all Okta assignments. 176 func (c *Client) DeleteAllOktaAssignments(ctx context.Context) error { 177 _, err := c.grpcClient.DeleteAllOktaAssignments(ctx, &oktapb.DeleteAllOktaAssignmentsRequest{}) 178 return trace.Wrap(err) 179 }