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  }