594 lines
17 KiB
Go
594 lines
17 KiB
Go
package tmobile
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/fiskerinc/cloud-services/pkg/grpc/sms"
|
|
"github.com/fiskerinc/cloud-services/pkg/logger"
|
|
"github.com/fiskerinc/cloud-services/pkg/utils/randomvalues"
|
|
"github.com/pkg/errors"
|
|
errorsO "errors"
|
|
|
|
tmtg "github.com/fiskerinc/cloud-services/pkg/tmobtokengen"
|
|
)
|
|
|
|
const (
|
|
failedToParseRequest = "failed to encode request: %v"
|
|
payloadMsg = "payload: %s"
|
|
contentType = "Content-Type"
|
|
failedGeneratePod = "failed to generate pop token: %v"
|
|
startingTMobileTimeout = time.Millisecond * 10
|
|
maximumTMobileTimeout = time.Minute
|
|
|
|
Endpoint = "https://adn.t-mobile.com"
|
|
)
|
|
|
|
var (
|
|
fakeIDGenerator = randomvalues.NewNonCryptoGenerator("1234567890", 0)
|
|
currentTMobileTimeout = startingTMobileTimeout
|
|
)
|
|
|
|
type httpClienter interface {
|
|
Do(req *http.Request) (*http.Response, error)
|
|
}
|
|
|
|
type TMobClienter interface {
|
|
AccessToken(ctx context.Context) (out *AccessTokenResponse, err error)
|
|
SetAccessToken(accessToken string)
|
|
SendSMS(ctx context.Context, in *SendSMSRequest) (out *SendSMSResponse, err error)
|
|
Details(ctx context.Context, ID string) (out *SMSDetailsResponse, err error)
|
|
ChangeRatePlan(context.Context, *ChangeRatePlanRequest) (*ChangeRatePlanResponse, error)
|
|
CustomAttributes(context.Context, *CustomAtributesRequest) (*CustomAtributesResponse, error)
|
|
GetProducts(context.Context, *sms.GetAvailableProductsRequest) (*sms.GetAvailableProductsResponse, error)
|
|
DeviceDetails(context.Context, *DeviceDetailsRequest) (*DeviceDetailsResponse, error)
|
|
ChangeDeviceStatus(ctx context.Context, cda ChangeDeviceActivation) (err error)
|
|
|
|
SetFilter(filter []string)
|
|
}
|
|
|
|
type TMobClient struct {
|
|
tg tmtg.Generator
|
|
client httpClienter
|
|
accessToken string
|
|
baseURL *url.URL
|
|
lock sync.RWMutex // Using a read-write mutex and anyone can send a sms at any time, but if the token is do for a renew, we should stop sending sms for a second
|
|
toRefresh <-chan time.Time
|
|
iccidFilter ICCIDFilter
|
|
}
|
|
|
|
|
|
var _ TMobClienter = &TMobClient{}
|
|
|
|
const (
|
|
Authorization = "Authorization"
|
|
XAuthorization = "X-Authorization"
|
|
XAuthOriginator = "x-auth-originator"
|
|
failedToDoRequest = "failed to do request"
|
|
applicationJSON = "application/json"
|
|
)
|
|
|
|
// baseURLstr: in the url to tmobile i.e. "https://core.saas.api.t-mobile.com"
|
|
// tg: should have been initiated with the correct keys. I believe this service should do it itself given the correct input
|
|
// timeout: The amount of time the http client will do a request before it gives up doing the request
|
|
func NewTMobileClient(baseURLstr string, tg tmtg.Generator, timeout time.Duration) (*TMobClient, error) {
|
|
u, err := url.Parse(baseURLstr)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, "failed to parse base URL")
|
|
}
|
|
|
|
tmb := &TMobClient{
|
|
baseURL: u,
|
|
tg: tg,
|
|
client: &http.Client{
|
|
Timeout: timeout,
|
|
},
|
|
toRefresh: make(<-chan time.Time),
|
|
}
|
|
tmb.refresh(context.Background())
|
|
|
|
tmb.iccidFilter = InitFilter()
|
|
return tmb, nil
|
|
}
|
|
|
|
func (c *TMobClient) do(req *http.Request, out interface{}) error {
|
|
|
|
resp, err := c.client.Do(req)
|
|
if err != nil {
|
|
return errors.WithMessagef(ErrDoRequest, "failed to do request: %v", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode >= 300 {
|
|
var body []byte
|
|
body, err = io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return errors.WithMessagef(ErrReadResponseBody, "failed to read response body: %v", err)
|
|
}
|
|
|
|
toWrapErr := ErrBadStatusCode
|
|
if resp.StatusCode == http.StatusUnauthorized {
|
|
toWrapErr = ErrAccessTokenExpired
|
|
} else if resp.StatusCode == http.StatusBadGateway {
|
|
toWrapErr = ErrBadGatewayCode
|
|
} else if resp.StatusCode == http.StatusGatewayTimeout {
|
|
toWrapErr = ErrBadGatewayCode
|
|
}
|
|
|
|
return errors.WithMessagef(toWrapErr, "request failed with status code %d, body: %s", resp.StatusCode, string(body))
|
|
}
|
|
|
|
err = json.NewDecoder(resp.Body).Decode(out)
|
|
if err != nil {
|
|
return errors.WithMessagef(ErrJSONMarshal, "failed to decode response: %v", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Must call setAccessToken after calling this function to set the access token
|
|
func (c *TMobClient) AccessToken(ctx context.Context) (out *AccessTokenResponse, err error) {
|
|
path := "/oauth2/v1/tokens"
|
|
|
|
c.lock.Lock()
|
|
defer c.lock.Unlock()
|
|
emap := make(tmtg.EHTSMap).SetAuthorization(c.tg.ClientSecretAsAuthVal()).
|
|
SetURI(path).
|
|
SetHTTPMethod(http.MethodPost)
|
|
|
|
token, err := c.tg.Generate(emap)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
fullPath := c.baseURL.String() + path
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, fullPath, nil)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrCreateRequest, "failed to create request")
|
|
}
|
|
|
|
req.Header.Set(Authorization, c.tg.ClientSecretAsAuthVal())
|
|
req.Header.Set(XAuthorization, token)
|
|
|
|
err = c.do(req, &out)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, failedToDoRequest)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (c *TMobClient) SetAccessToken(accessToken string) {
|
|
c.accessToken = "Bearer " + accessToken
|
|
}
|
|
|
|
func (c *TMobClient) SendSMS(ctx context.Context, in *SendSMSRequest) (out *SendSMSResponse, err error) {
|
|
if !c.iccidFilter.ShouldSend(in.ICCID) {
|
|
out = &SendSMSResponse{
|
|
SmsMessageID: fakeSMSID(),
|
|
}
|
|
return
|
|
}
|
|
path := "/eitcsr-iotcp-notifications-v2/prd02/iotcp/v2/notifications/sms/messages"
|
|
|
|
payload := new(bytes.Buffer)
|
|
if err = json.NewEncoder(payload).Encode(in); err != nil {
|
|
return nil, errors.WithMessagef(ErrJSONMarshal, failedToParseRequest, err)
|
|
}
|
|
|
|
payloadStr := payload.String()
|
|
|
|
emap := make(tmtg.EHTSMap).SetAuthorization(c.accessToken).
|
|
SetURI(path).
|
|
SetHTTPMethod(http.MethodPost).
|
|
SetContentType(applicationJSON).
|
|
SetBody(payloadStr)
|
|
|
|
logger.Debug().Msgf(payloadMsg, payloadStr)
|
|
|
|
token, err := c.tg.Generate(emap)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrTokenGen, "failed to generate token: %v", err)
|
|
}
|
|
|
|
fullPath := c.baseURL.String() + path
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, fullPath, bytes.NewBufferString(payloadStr))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c.lock.RLock()
|
|
defer c.lock.RUnlock()
|
|
req.Header.Set(Authorization, c.accessToken)
|
|
req.Header.Set(XAuthOriginator, ToXAuthOriginator(c.accessToken))
|
|
req.Header.Set(XAuthorization, token)
|
|
req.Header.Set(contentType, applicationJSON)
|
|
|
|
err = c.do(req, &out)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, failedToDoRequest)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (c *TMobClient) Details(ctx context.Context, ID string) (out *SMSDetailsResponse, err error) {
|
|
path := fmt.Sprintf("/eitcsr-iotcp-notifications-v2/prd02/iotcp/v2/notifications/sms/messages/%s", ID)
|
|
|
|
emap := make(tmtg.EHTSMap).SetAuthorization(c.accessToken).
|
|
SetURI(path).
|
|
SetHTTPMethod(http.MethodGet)
|
|
|
|
token, err := c.tg.Generate(emap)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrTokenGen, "failed to generate token: %v", err)
|
|
}
|
|
|
|
fullPath := c.baseURL.String() + path
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, fullPath, nil)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrCreateRequest, "failed to create request: %v", err)
|
|
}
|
|
|
|
c.lock.RLock()
|
|
defer c.lock.RUnlock()
|
|
req.Header.Set(Authorization, c.accessToken)
|
|
req.Header.Set(XAuthOriginator, ToXAuthOriginator(c.accessToken))
|
|
req.Header.Set(XAuthorization, token)
|
|
req.Header.Set(contentType, applicationJSON)
|
|
|
|
err = c.do(req, &out)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, failedToDoRequest)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func InitTokenGen(pkVal, clientId, secret string) (*tmtg.PopTokenGenerator, error) {
|
|
// No reason to take a variable and write it to a text file and then read it from the text file
|
|
|
|
tg, err := tmtg.NewTokenGenerator(
|
|
clientId,
|
|
secret,
|
|
time.Minute*2,
|
|
pkVal, // path to public key file
|
|
)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, "failed to create token generator")
|
|
}
|
|
|
|
return tg, nil
|
|
}
|
|
|
|
func (c *TMobClient) ChangeRatePlan(ctx context.Context, in *ChangeRatePlanRequest) (*ChangeRatePlanResponse, error) {
|
|
path := "/eitcsr-iotcp-line-of-service-v1/prd02/iotcp/v1/line-of-service/devices/change-rate-plan"
|
|
fullPath := c.baseURL.String() + path
|
|
|
|
// The in body is so small, no use in using the encode method
|
|
payload := new(bytes.Buffer)
|
|
if err := json.NewEncoder(payload).Encode(in); err != nil {
|
|
return nil, errors.WithMessagef(ErrJSONMarshal, failedToParseRequest, err)
|
|
}
|
|
payloadStr := payload.String()
|
|
|
|
emap := make(tmtg.EHTSMap).SetAuthorization(c.accessToken).
|
|
SetURI(path).
|
|
SetHTTPMethod(http.MethodPost).
|
|
SetContentType(applicationJSON).
|
|
SetBody(payloadStr)
|
|
|
|
logger.Debug().Msgf(payloadMsg, payloadStr)
|
|
popToken, err := c.tg.Generate(emap)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrTokenGen, failedGeneratePod, err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, fullPath, payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c.lock.RLock()
|
|
defer c.lock.RUnlock()
|
|
req.Header.Set(Authorization, c.accessToken)
|
|
req.Header.Set(XAuthOriginator, ToXAuthOriginator(c.accessToken))
|
|
req.Header.Set(XAuthorization, popToken)
|
|
req.Header.Set(contentType, applicationJSON)
|
|
out := &ChangeRatePlanResponse{}
|
|
|
|
err = c.do(req, out)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, failedToDoRequest)
|
|
}
|
|
|
|
return out, nil
|
|
}
|
|
|
|
func (c *TMobClient) CustomAttributes(ctx context.Context, in *CustomAtributesRequest) (*CustomAtributesResponse, error) {
|
|
path := "/eitcsr-iotcp-line-of-service-v1/prd02/iotcp/v1/line-of-service/devices/device-attributes"
|
|
fullPath := c.baseURL.String() + path
|
|
|
|
payload := new(bytes.Buffer)
|
|
if err := json.NewEncoder(payload).Encode(in); err != nil {
|
|
return nil, errors.WithMessagef(ErrJSONMarshal, failedToParseRequest, err)
|
|
}
|
|
payloadStr := payload.String()
|
|
|
|
emap := make(tmtg.EHTSMap).SetAuthorization(c.accessToken).
|
|
SetURI(path).
|
|
SetHTTPMethod(http.MethodPost).
|
|
SetContentType(applicationJSON).
|
|
SetBody(payloadStr)
|
|
|
|
logger.Debug().Msgf(payloadMsg, payloadStr)
|
|
popToken, err := c.tg.Generate(emap)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrTokenGen, failedGeneratePod, err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, fullPath, payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c.lock.RLock()
|
|
defer c.lock.RUnlock()
|
|
req.Header.Set(Authorization, c.accessToken)
|
|
req.Header.Set(XAuthOriginator, ToXAuthOriginator(c.accessToken))
|
|
req.Header.Set(XAuthorization, popToken)
|
|
req.Header.Set(contentType, applicationJSON)
|
|
out := &CustomAtributesResponse{}
|
|
|
|
err = c.do(req, out)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, failedToDoRequest)
|
|
}
|
|
|
|
return out, nil
|
|
}
|
|
|
|
func (c *TMobClient) GetProducts(ctx context.Context, in *sms.GetAvailableProductsRequest) (*sms.GetAvailableProductsResponse, error) {
|
|
path := "/eitcsr-iot-product-service-v1/prd02/iotcp/v1/iot-product-service/products/query"
|
|
fullPath := c.baseURL.String() + path
|
|
|
|
payload := new(bytes.Buffer)
|
|
if err := json.NewEncoder(payload).Encode(in); err != nil {
|
|
return nil, errors.WithMessagef(ErrJSONMarshal, failedToParseRequest, err)
|
|
}
|
|
payloadStr := payload.String()
|
|
|
|
emap := make(tmtg.EHTSMap).SetAuthorization(c.accessToken).
|
|
SetURI(path).
|
|
SetHTTPMethod(http.MethodPost).
|
|
SetContentType(applicationJSON).
|
|
SetBody(payloadStr)
|
|
|
|
logger.Debug().Msgf(payloadMsg, payloadStr)
|
|
popToken, err := c.tg.Generate(emap)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrTokenGen, failedGeneratePod, err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, fullPath, payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c.lock.RLock()
|
|
defer c.lock.RUnlock()
|
|
req.Header.Set(Authorization, c.accessToken)
|
|
req.Header.Set(XAuthOriginator, ToXAuthOriginator(c.accessToken))
|
|
req.Header.Set(XAuthorization, popToken)
|
|
req.Header.Set(contentType, applicationJSON)
|
|
out := &sms.GetAvailableProductsResponse{}
|
|
|
|
err = c.do(req, &out.AvailableProducts)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, failedToDoRequest)
|
|
}
|
|
|
|
return out, nil
|
|
}
|
|
|
|
func (c *TMobClient) DeviceDetails(ctx context.Context, in *DeviceDetailsRequest) (*DeviceDetailsResponse, error) {
|
|
path := "/eitcsr-iotcp-line-of-service-v1/prd02/iotcp/v1/line-of-service/devices/details"
|
|
fullPath := c.baseURL.String() + path
|
|
|
|
payload := new(bytes.Buffer)
|
|
if err := json.NewEncoder(payload).Encode(in); err != nil {
|
|
return nil, errors.WithMessagef(ErrJSONMarshal, failedToParseRequest, err)
|
|
}
|
|
payloadStr := payload.String()
|
|
|
|
emap := make(tmtg.EHTSMap).SetAuthorization(c.accessToken).
|
|
SetURI(path).
|
|
SetHTTPMethod(http.MethodPost).
|
|
SetContentType(applicationJSON).
|
|
SetBody(payloadStr)
|
|
|
|
logger.Debug().Msgf(payloadMsg, payloadStr)
|
|
popToken, err := c.tg.Generate(emap)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrTokenGen, failedGeneratePod, err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, fullPath, payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c.lock.RLock()
|
|
defer c.lock.RUnlock()
|
|
req.Header.Set(Authorization, c.accessToken)
|
|
req.Header.Set(XAuthOriginator, ToXAuthOriginator(c.accessToken))
|
|
req.Header.Set(XAuthorization, popToken)
|
|
req.Header.Set(contentType, applicationJSON)
|
|
out := &DeviceDetailsResponse{}
|
|
|
|
err = c.do(req, &out)
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, failedToDoRequest)
|
|
}
|
|
|
|
return out, nil
|
|
}
|
|
|
|
func (c *TMobClient) refresh(ctx context.Context) {
|
|
var expiresIn time.Duration
|
|
|
|
at, err := c.AccessToken(ctx)
|
|
if err != nil {
|
|
logger.Error().Msgf("failed to get access token: %v", err)
|
|
expiresIn = currentTMobileTimeout
|
|
currentTMobileTimeout = currentTMobileTimeout * currentTMobileTimeout
|
|
if currentTMobileTimeout > maximumTMobileTimeout {
|
|
currentTMobileTimeout = maximumTMobileTimeout
|
|
}
|
|
|
|
} else {
|
|
expiresIn = time.Duration(at.ExpiresIn) * time.Second
|
|
expiresIn -= time.Minute * 1 // Expire 1 minute earlier than needed. Previous code was refreshing in half the time
|
|
c.SetAccessToken(at.AccessToken)
|
|
logger.Info().Msgf("Refreshed access token, expires in %s", expiresIn)
|
|
// Reset the increasing timeout
|
|
currentTMobileTimeout = startingTMobileTimeout
|
|
}
|
|
|
|
time.AfterFunc(expiresIn, func() { c.refresh(context.Background()) })
|
|
}
|
|
|
|
// SetFilter implements TMobClienter.
|
|
func (c *TMobClient) SetFilter(filter []string) {
|
|
c.iccidFilter = ICCIDFilter{
|
|
filter: filter,
|
|
}
|
|
}
|
|
|
|
// SmsMessageID is a string consisting of numbers, will return a marker showing its not real
|
|
func fakeSMSID() (fakeID string) {
|
|
return fmt.Sprintf("FAKE_SMS_ID:%s", fakeIDGenerator.GetString(10))
|
|
}
|
|
|
|
func IsRealSMSID(smsID string) (isReal bool) {
|
|
return !strings.HasPrefix(smsID, "FAKE_SMS_ID:")
|
|
}
|
|
|
|
|
|
// HandleChangeDeviceStatus implements TMobClienter.
|
|
func (c *TMobClient) ChangeDeviceStatus(ctx context.Context, cda ChangeDeviceActivation) (err error) {
|
|
var fn func(ctx context.Context, in *ICCIDBody)(out *ICCIDBody, err error)
|
|
if cda.Enabled {
|
|
fn = c.handleServiceRestore
|
|
}else {
|
|
fn = c.handleServiceCancel
|
|
}
|
|
for _, iccid := range cda.ICCIDs {
|
|
iccid = strings.TrimSuffix(strings.TrimSuffix(iccid, "F"), "f")
|
|
temp := ICCIDBody{
|
|
ICCID: iccid,
|
|
}
|
|
_, tErr := fn(ctx, &temp)
|
|
if tErr != nil {
|
|
err = errorsO.Join(err, tErr)
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
// sets status as ACTIVATED
|
|
func (c *TMobClient) handleServiceRestore(ctx context.Context, in *ICCIDBody)(out *ICCIDBody, err error){
|
|
path := "/eitcsr-iotcp-line-of-service-v1/prd02/iotcp/v1/line-of-service/devices/service-restore"
|
|
fullPath := c.baseURL.String() + path
|
|
|
|
payload := new(bytes.Buffer)
|
|
err = json.NewEncoder(payload).Encode(in)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrJSONMarshal, failedToParseRequest, err)
|
|
}
|
|
payloadStr := payload.String()
|
|
|
|
emap := make(tmtg.EHTSMap).SetAuthorization(c.accessToken).
|
|
SetURI(path).
|
|
SetHTTPMethod(http.MethodPost).
|
|
SetContentType(applicationJSON).
|
|
SetBody(payloadStr)
|
|
popToken, err := c.tg.Generate(emap)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrTokenGen, failedGeneratePod, err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, fullPath, payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c.lock.RLock()
|
|
defer c.lock.RUnlock()
|
|
req.Header.Set(Authorization, c.accessToken)
|
|
req.Header.Set(XAuthOriginator, ToXAuthOriginator(c.accessToken))
|
|
req.Header.Set(XAuthorization, popToken)
|
|
req.Header.Set(contentType, applicationJSON)
|
|
out = &ICCIDBody{}
|
|
|
|
err = c.do(req, &out)
|
|
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, failedToDoRequest)
|
|
}
|
|
return
|
|
}
|
|
|
|
// sets status as DEACTIVATED
|
|
func (c *TMobClient) handleServiceCancel(ctx context.Context, in *ICCIDBody)(out *ICCIDBody, err error){
|
|
path := "/eitcsr-iotcp-line-of-service-v1/prd02/iotcp/v1/line-of-service/devices/service-suspend"
|
|
fullPath := c.baseURL.String() + path
|
|
|
|
payload := new(bytes.Buffer)
|
|
err = json.NewEncoder(payload).Encode(in)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrJSONMarshal, failedToParseRequest, err)
|
|
}
|
|
payloadStr := payload.String()
|
|
|
|
emap := make(tmtg.EHTSMap).SetAuthorization(c.accessToken).
|
|
SetURI(path).
|
|
SetHTTPMethod(http.MethodPost).
|
|
SetContentType(applicationJSON).
|
|
SetBody(payloadStr)
|
|
popToken, err := c.tg.Generate(emap)
|
|
if err != nil {
|
|
return nil, errors.WithMessagef(ErrTokenGen, failedGeneratePod, err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, fullPath, payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
c.lock.RLock()
|
|
defer c.lock.RUnlock()
|
|
req.Header.Set(Authorization, c.accessToken)
|
|
req.Header.Set(XAuthOriginator, ToXAuthOriginator(c.accessToken))
|
|
req.Header.Set(XAuthorization, popToken)
|
|
req.Header.Set(contentType, applicationJSON)
|
|
out = &ICCIDBody{}
|
|
|
|
err = c.do(req, &out)
|
|
|
|
if err != nil {
|
|
return nil, errors.WithMessage(err, failedToDoRequest)
|
|
}
|
|
return
|
|
}
|