From 2c7abf00a1cb8a7115716fba0f248ecb346348a7 Mon Sep 17 00:00:00 2001 From: Tim Heckman Date: Thu, 25 Feb 2021 17:46:04 -0800 Subject: [PATCH] Update user.go to accept a context.Context Updates #267 --- user.go | 237 ++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 188 insertions(+), 49 deletions(-) diff --git a/user.go b/user.go index d232b1c6..60331a5d 100644 --- a/user.go +++ b/user.go @@ -89,59 +89,109 @@ type GetCurrentUserOptions struct { Includes []string `url:"include,omitempty,brackets"` } -// ListUsers lists users of your PagerDuty account, optionally filtered by a search query. +// ListUsers lists users of your PagerDuty account, optionally filtered by a +// search query. It's recommended to use ListUsersWithContext instead. func (c *Client) ListUsers(o ListUsersOptions) (*ListUsersResponse, error) { + return c.ListUsersWithContext(context.Background(), o) +} + +// ListUsersWithContext lists users of your PagerDuty account, optionally filtered by a search query. +func (c *Client) ListUsersWithContext(ctx context.Context, o ListUsersOptions) (*ListUsersResponse, error) { v, err := query.Values(o) if err != nil { return nil, err } - resp, err := c.get(context.TODO(), "/users?"+v.Encode()) + + resp, err := c.get(ctx, "/users?"+v.Encode()) if err != nil { return nil, err } + var result ListUsersResponse - return &result, c.decodeJSON(resp, &result) + if err := c.decodeJSON(resp, &result); err != nil { + return nil, err + } + + return &result, nil } -// CreateUser creates a new user. +// CreateUser creates a new user. It's recommended to use CreateUserWithContext +// instead. func (c *Client) CreateUser(u User) (*User, error) { - data := make(map[string]User) - data["user"] = u - resp, err := c.post(context.TODO(), "/users", data, nil) + return c.CreateUserWithContext(context.Background(), u) +} + +// CreateUserWithContext creates a new user. +func (c *Client) CreateUserWithContext(ctx context.Context, u User) (*User, error) { + d := map[string]User{ + "user": u, + } + + resp, err := c.post(ctx, "/users", d, nil) return getUserFromResponse(c, resp, err) } -// DeleteUser deletes a user. +// DeleteUser deletes a user. It's recommended to use DeleteUserWithContext +// instead. func (c *Client) DeleteUser(id string) error { - _, err := c.delete(context.TODO(), "/users/"+id) + return c.DeleteUserWithContext(context.Background(), id) +} + +// DeleteUserWithContext deletes a user. +func (c *Client) DeleteUserWithContext(ctx context.Context, id string) error { + _, err := c.delete(ctx, "/users/"+id) return err } -// GetUser gets details about an existing user. +// GetUser gets details about an existing user. It's recommended to use +// GetUserWithContext instead. func (c *Client) GetUser(id string, o GetUserOptions) (*User, error) { + return c.GetUserWithContext(context.Background(), id, o) +} + +// GetUserWithContext gets details about an existing user. +func (c *Client) GetUserWithContext(ctx context.Context, id string, o GetUserOptions) (*User, error) { v, err := query.Values(o) if err != nil { return nil, err } - resp, err := c.get(context.TODO(), "/users/"+id+"?"+v.Encode()) + + resp, err := c.get(ctx, "/users/"+id+"?"+v.Encode()) return getUserFromResponse(c, resp, err) } -// UpdateUser updates an existing user. +// UpdateUser updates an existing user. It's recommended to use +// UpdateUserWithContext instead. func (c *Client) UpdateUser(u User) (*User, error) { - v := make(map[string]User) - v["user"] = u - resp, err := c.put(context.TODO(), "/users/"+u.ID, v, nil) + return c.UpdateUserWithContext(context.Background(), u) +} + +// UpdateUserWithContext updates an existing user. +func (c *Client) UpdateUserWithContext(ctx context.Context, u User) (*User, error) { + d := map[string]User{ + "user": u, + } + + resp, err := c.put(ctx, "/users/"+u.ID, d, nil) return getUserFromResponse(c, resp, err) } -// GetCurrentUser gets details about the authenticated user when using a user-level API key or OAuth token +// GetCurrentUser gets details about the authenticated user when using a +// user-level API key or OAuth token. It's recommended to use +// GetCurrentUserWithContext instead. func (c *Client) GetCurrentUser(o GetCurrentUserOptions) (*User, error) { + return c.GetCurrentUserWithContext(context.Background(), o) +} + +// GetCurrentUserWithContext gets details about the authenticated user when +// using a user-level API key or OAuth token. +func (c *Client) GetCurrentUserWithContext(ctx context.Context, o GetCurrentUserOptions) (*User, error) { v, err := query.Values(o) if err != nil { return nil, err } - resp, err := c.get(context.TODO(), "/users/me?"+v.Encode()) + + resp, err := c.get(ctx, "/users/me?"+v.Encode()) return getUserFromResponse(c, resp, err) } @@ -149,53 +199,96 @@ func getUserFromResponse(c *Client, resp *http.Response, err error) (*User, erro if err != nil { return nil, err } + var target map[string]User if dErr := c.decodeJSON(resp, &target); dErr != nil { return nil, fmt.Errorf("Could not decode JSON response: %v", dErr) } - rootNode := "user" + + const rootNode = "user" + t, nodeOK := target[rootNode] if !nodeOK { return nil, fmt.Errorf("JSON response does not have %s field", rootNode) } + return &t, nil } -// ListUserContactMethods fetches contact methods of the existing user. +// ListUserContactMethods fetches contact methods of the existing user. It's +// recommended to use ListUserContactMethodsWithContext instead. func (c *Client) ListUserContactMethods(userID string) (*ListContactMethodsResponse, error) { - resp, err := c.get(context.TODO(), "/users/"+userID+"/contact_methods") + return c.ListUserContactMethodsWithContext(context.Background(), userID) +} + +// ListUserContactMethodsWithContext fetches contact methods of the existing user. +func (c *Client) ListUserContactMethodsWithContext(ctx context.Context, userID string) (*ListContactMethodsResponse, error) { + resp, err := c.get(ctx, "/users/"+userID+"/contact_methods") if err != nil { return nil, err } + var result ListContactMethodsResponse - return &result, c.decodeJSON(resp, &result) + if err := c.decodeJSON(resp, &result); err != nil { + return nil, err + } + + return &result, nil } -// GetUserContactMethod gets details about a contact method. +// GetUserContactMethod gets details about a contact method. It's recommended to +// use GetUserContactMethodWithContext instead. func (c *Client) GetUserContactMethod(userID, contactMethodID string) (*ContactMethod, error) { - resp, err := c.get(context.TODO(), "/users/"+userID+"/contact_methods/"+contactMethodID) + return c.GetUserContactMethodWithContext(context.Background(), userID, contactMethodID) +} + +// GetUserContactMethodWithContext gets details about a contact method. +func (c *Client) GetUserContactMethodWithContext(ctx context.Context, userID, contactMethodID string) (*ContactMethod, error) { + resp, err := c.get(ctx, "/users/"+userID+"/contact_methods/"+contactMethodID) return getContactMethodFromResponse(c, resp, err) } -// DeleteUserContactMethod deletes a user. +// DeleteUserContactMethod deletes a user. It's recommended to use +// DeleteUserContactMethodWithContext instead. func (c *Client) DeleteUserContactMethod(userID, contactMethodID string) error { - _, err := c.delete(context.TODO(), "/users/"+userID+"/contact_methods/"+contactMethodID) + return c.DeleteUserContactMethodWithContext(context.Background(), userID, contactMethodID) +} + +// DeleteUserContactMethodWithContext deletes a user. +func (c *Client) DeleteUserContactMethodWithContext(ctx context.Context, userID, contactMethodID string) error { + _, err := c.delete(ctx, "/users/"+userID+"/contact_methods/"+contactMethodID) return err } -// CreateUserContactMethod creates a new contact method for user. +// CreateUserContactMethod creates a new contact method for user. It's +// recommended to use CreateUserContactMethodWithContext instead. func (c *Client) CreateUserContactMethod(userID string, cm ContactMethod) (*ContactMethod, error) { - data := make(map[string]ContactMethod) - data["contact_method"] = cm - resp, err := c.post(context.TODO(), "/users/"+userID+"/contact_methods", data, nil) + return c.CreateUserContactMethodWithContext(context.Background(), userID, cm) +} + +// CreateUserContactMethodWithContext creates a new contact method for user. +func (c *Client) CreateUserContactMethodWithContext(ctx context.Context, userID string, cm ContactMethod) (*ContactMethod, error) { + d := map[string]ContactMethod{ + "contact_method": cm, + } + + resp, err := c.post(ctx, "/users/"+userID+"/contact_methods", d, nil) return getContactMethodFromResponse(c, resp, err) } -// UpdateUserContactMethod updates an existing user. +// UpdateUserContactMethod updates an existing user. It's recommended to use +// UpdateUserContactMethodWithContext instead. func (c *Client) UpdateUserContactMethod(userID string, cm ContactMethod) (*ContactMethod, error) { - v := make(map[string]ContactMethod) - v["contact_method"] = cm - resp, err := c.put(context.TODO(), "/users/"+userID+"/contact_methods/"+cm.ID, v, nil) + return c.UpdateUserContactMethodWthContext(context.Background(), userID, cm) +} + +// UpdateUserContactMethodWthContext updates an existing user. +func (c *Client) UpdateUserContactMethodWthContext(ctx context.Context, userID string, cm ContactMethod) (*ContactMethod, error) { + d := map[string]ContactMethod{ + "contact_method": cm, + } + + resp, err := c.put(ctx, "/users/"+userID+"/contact_methods/"+cm.ID, d, nil) return getContactMethodFromResponse(c, resp, err) } @@ -203,68 +296,114 @@ func getContactMethodFromResponse(c *Client, resp *http.Response, err error) (*C if err != nil { return nil, err } + var target map[string]ContactMethod if dErr := c.decodeJSON(resp, &target); dErr != nil { return nil, fmt.Errorf("Could not decode JSON response: %v", dErr) } - rootNode := "contact_method" + + const rootNode = "contact_method" + t, nodeOK := target[rootNode] if !nodeOK { return nil, fmt.Errorf("JSON response does not have %s field", rootNode) } + return &t, nil } -// GetUserNotificationRule gets details about a notification rule. +// GetUserNotificationRule gets details about a notification rule. It's +// recommended to use GetUserNotificationRuleWithContext instead. func (c *Client) GetUserNotificationRule(userID, ruleID string) (*NotificationRule, error) { - resp, err := c.get(context.TODO(), "/users/"+userID+"/notification_rules/"+ruleID) + return c.GetUserNotificationRuleWithContext(context.Background(), userID, ruleID) +} + +// GetUserNotificationRuleWithContext gets details about a notification rule. +func (c *Client) GetUserNotificationRuleWithContext(ctx context.Context, userID, ruleID string) (*NotificationRule, error) { + resp, err := c.get(ctx, "/users/"+userID+"/notification_rules/"+ruleID) return getUserNotificationRuleFromResponse(c, resp, err) } -// CreateUserNotificationRule creates a new notification rule for a user. +// CreateUserNotificationRule creates a new notification rule for a user. It's +// recommended to use CreateUserNotificationRuleWithContext instead. func (c *Client) CreateUserNotificationRule(userID string, rule NotificationRule) (*NotificationRule, error) { - data := make(map[string]NotificationRule) - data["notification_rule"] = rule - resp, err := c.post(context.TODO(), "/users/"+userID+"/notification_rules", data, nil) + return c.CreateUserNotificationRuleWithContext(context.Background(), userID, rule) +} + +// CreateUserNotificationRuleWithContext creates a new notification rule for a user. +func (c *Client) CreateUserNotificationRuleWithContext(ctx context.Context, userID string, rule NotificationRule) (*NotificationRule, error) { + d := map[string]NotificationRule{ + "notification_rule": rule, + } + + resp, err := c.post(ctx, "/users/"+userID+"/notification_rules", d, nil) return getUserNotificationRuleFromResponse(c, resp, err) } -// UpdateUserNotificationRule updates a notification rule for a user. +// UpdateUserNotificationRule updates a notification rule for a user. It's +// recommended to use UpdateUserNotificationRuleWithContext instead. func (c *Client) UpdateUserNotificationRule(userID string, rule NotificationRule) (*NotificationRule, error) { - data := make(map[string]NotificationRule) - data["notification_rule"] = rule - resp, err := c.put(context.TODO(), "/users/"+userID+"/notification_rules/"+rule.ID, data, nil) + return c.UpdateUserNotificationRuleWithContext(context.Background(), userID, rule) +} + +// UpdateUserNotificationRuleWithContext updates a notification rule for a user. +func (c *Client) UpdateUserNotificationRuleWithContext(ctx context.Context, userID string, rule NotificationRule) (*NotificationRule, error) { + d := map[string]NotificationRule{ + "notification_rule": rule, + } + + resp, err := c.put(ctx, "/users/"+userID+"/notification_rules/"+rule.ID, d, nil) return getUserNotificationRuleFromResponse(c, resp, err) } -// DeleteUserNotificationRule deletes a notification rule for a user. +// DeleteUserNotificationRule deletes a notification rule for a user. It's +// recommended to use DeleteUserNotificationRuleWithContext instead. func (c *Client) DeleteUserNotificationRule(userID, ruleID string) error { - _, err := c.delete(context.TODO(), "/users/"+userID+"/notification_rules/"+ruleID) + return c.DeleteUserNotificationRuleWithContext(context.Background(), userID, ruleID) +} + +// DeleteUserNotificationRuleWithContext deletes a notification rule for a user. +func (c *Client) DeleteUserNotificationRuleWithContext(ctx context.Context, userID, ruleID string) error { + _, err := c.delete(ctx, "/users/"+userID+"/notification_rules/"+ruleID) return err } // ListUserNotificationRules fetches notification rules of the existing user. func (c *Client) ListUserNotificationRules(userID string) (*ListUserNotificationRulesResponse, error) { - resp, err := c.get(context.TODO(), "/users/"+userID+"/notification_rules") + return c.ListUserNotificationRulesWithContext(context.Background(), userID) +} + +// ListUserNotificationRulesWithContext fetches notification rules of the existing user. +func (c *Client) ListUserNotificationRulesWithContext(ctx context.Context, userID string) (*ListUserNotificationRulesResponse, error) { + resp, err := c.get(ctx, "/users/"+userID+"/notification_rules") if err != nil { return nil, err } + var result ListUserNotificationRulesResponse - return &result, c.decodeJSON(resp, &result) + if err := c.decodeJSON(resp, &result); err != nil { + return nil, err + } + + return &result, nil } func getUserNotificationRuleFromResponse(c *Client, resp *http.Response, err error) (*NotificationRule, error) { if err != nil { return nil, err } + var target map[string]NotificationRule if dErr := c.decodeJSON(resp, &target); dErr != nil { return nil, fmt.Errorf("Could not decode JSON response: %v", dErr) } - rootNode := "notification_rule" + + const rootNode = "notification_rule" + t, nodeOK := target[rootNode] if !nodeOK { return nil, fmt.Errorf("JSON response does not have %s field", rootNode) } + return &t, nil }