def _logout(
self,
sudo: bool = False,
transport_options: Optional[transport.TransportOptions] = None,
) -> None:
if sudo:
token = self.sudo_token.access_token
self.sudo_token = auth_token.AuthToken()
else:
token = self.token.access_token
self.token = auth_token.AuthToken()
def authenticator(
_transport_options: transport.TransportOptions,
) -> Dict[str, str]:
return {"Authorization": f"Bearer {token}"}
self._ok(
self.transport.request(
transport.HttpMethod.DELETE,
f"{self.settings.base_url}/api/logout",
authenticator=authenticator,
transport_options=transport_options,
)
)
def __init__(
self,
settings: api_settings.ApiSettings,
transport: transport.Transport,
deserialize: serialize.TDeserialize,
):
self.user_token: auth_token.AuthToken = auth_token.AuthToken()
self.admin_token: auth_token.AuthToken = auth_token.AuthToken()
self._sudo_id: Optional[int] = None
self.settings = settings
self.transport = transport
self.deserialize = deserialize
def _logout(self, sudo: bool = False) -> None:
if sudo:
token = self.sudo_token.access_token
self.sudo_token = auth_token.AuthToken()
else:
token = self.token.access_token
self.token = auth_token.AuthToken()
self._ok(
self.transport.request(
transport.HttpMethod.DELETE,
f"{self.settings.base_url}/api/logout",
authenticator=lambda: {"Authorization": f"Bearer {token}"},
))
def __init__(
self,
settings: api_settings.PApiSettings,
transport: transport.Transport,
deserialize: serialize.TDeserialize,
):
if not settings.is_configured():
raise error.SDKError(
"Missing required configuration values like base_url and api_version."
)
self.settings = settings
self.user_token: auth_token.AuthToken = auth_token.AuthToken()
self.admin_token: auth_token.AuthToken = auth_token.AuthToken()
self._sudo_id: Optional[int] = None
self.transport = transport
self.deserialize = deserialize
def __init__(
self,
settings: api_settings.PApiSettings,
transport: transport.Transport,
deserialize: serialize.TDeserialize,
api_version: str,
):
settings.is_configured()
self.settings = settings
self.api_version = api_version
self.sudo_token: auth_token.AuthToken = auth_token.AuthToken()
self.token: auth_token.AuthToken = auth_token.AuthToken()
self._sudo_id: Optional[int] = None
self.transport = transport
self.deserialize = deserialize
self.token_model = auth_token.AccessToken
def _login(self) -> None:
client_id = self.settings.read_config().get("client_id")
client_secret = self.settings.read_config().get("client_secret")
if not (client_id and client_secret):
raise error.SDKError("Required auth credentials not found.")
serialized = urllib.parse.urlencode({
"client_id":
cast(str, client_id),
"client_secret":
cast(str, client_secret),
}).encode("utf-8")
response = self._ok(
self.transport.request(
transport.HttpMethod.POST,
f"{self.settings.base_url}/api/{self.version}/login",
body=serialized,
headers={"Content-Type": "application/x-www-form-urlencoded"},
))
# ignore type: mypy bug doesn't recognized kwarg `structure` to partial func
access_token = self.deserialize(
data=response, structure=self.token_model) # type: ignore
assert isinstance(access_token, token_model_isinstances)
self.token = auth_token.AuthToken(access_token)
def _login_admin(self) -> None:
config_data = self.settings.read_ini(self.settings._filename,
self.settings._section)
client_id = os.getenv(f"{versions.environment_prefix}_CLIENT_ID"
) or config_data.get("client_id")
client_secret = os.getenv(
f"{versions.environment_prefix}_CLIENT_SECRET") or config_data.get(
"client_secret")
if not (client_id and client_secret):
raise error.SDKError("Required auth credentials not found.")
serialized = urllib.parse.urlencode({
"client_id":
cast(str, client_id),
"client_secret":
cast(str, client_secret),
}).encode("utf-8")
response = self._ok(
self.transport.request(
transport.HttpMethod.POST,
"/login",
body=serialized,
headers={"Content-Type": "application/x-www-form-urlencoded"},
))
access_token = self.deserialize(response, models.AccessToken)
assert isinstance(access_token, models.AccessToken)
self.admin_token = auth_token.AuthToken(access_token)
def _login(self, transport_options: transport.TransportOptions) -> None:
params = self.RefreshTokenGrantTypeParams(
client_id=self.client_id,
redirect_uri=self.redirect_uri,
refresh_token=self.token.refresh_token,
)
access_token = self._request_token(params, transport_options)
self.token = auth_token.AuthToken(access_token)
def test_defaults_with_empty_token():
"""Confirm the defaults when initializing AuthToken without arguments."""
actual = auth_token.AuthToken()
assert actual.access_token == ""
assert actual.token_type == ""
assert actual.expires_in == 0
assert actual.is_active is False
def _login(self) -> None:
params = self.RefreshTokenGrantTypeParams(
client_id=self.client_id,
redirect_uri=self.redirect_uri,
refresh_token=self.token.refresh_token,
)
access_token = self._request_token(params)
self.token = auth_token.AuthToken(access_token)
def test_lag_time_is_used():
"""Confirm active token when expiration is > lag time."""
actual = auth_token.AuthToken(
models.AccessToken(
access_token="all-access", token_type="backstage", expires_in=9
)
)
assert actual.access_token == "all-access"
assert actual.token_type == "backstage"
assert actual.expires_in == 9
assert actual.is_active is False
actual = auth_token.AuthToken(
models.AccessToken(
access_token="all-access", token_type="backstage", expires_in=11
)
)
assert actual.expires_in == 11
assert actual.is_active is True
def test_is_active_with_full_token():
"""Confirm active token when AuthToken is initialized properly."""
actual = auth_token.AuthToken(
models.AccessToken(
access_token="all-access", token_type="backstage", expires_in=3600
)
)
assert actual.access_token == "all-access"
assert actual.token_type == "backstage"
assert actual.expires_in == 3600
assert actual.is_active is True
def redeem_auth_code(self,
auth_code: str,
code_verifier: Optional[str] = None) -> None:
params = self.AuthCodeGrantTypeParams(
client_id=self.client_id,
redirect_uri=self.redirect_uri,
code=auth_code,
code_verifier=code_verifier or self.code_verifier,
)
access_token = self._request_token(params)
self.token = auth_token.AuthToken(access_token)
def _login_user(self) -> None:
response = self._ok(
self.transport.request(
transport.HttpMethod.POST,
f"/login/{self._sudo_id}",
authenticator=lambda: {
"Authorization":
f"token {self._get_admin_token().access_token}"
},
))
access_token = self.deserialize(response, models.AccessToken)
assert isinstance(access_token, models.AccessToken)
self.user_token = auth_token.AuthToken(access_token)
def _login_sudo(self) -> None:
response = self._ok(
self.transport.request(
transport.HttpMethod.POST,
f"{self.settings.base_url}/api/{self.version}/login/{self._sudo_id}",
authenticator=lambda:
{"Authorization": f"Bearer {self._get_token().access_token}"},
))
# ignore type: mypy bug doesn't recognized kwarg `structure` to partial func
access_token = self.deserialize(
data=response, structure=self.token_model) # type: ignore
assert isinstance(access_token, token_model_isinstances)
self.sudo_token = auth_token.AuthToken(access_token)
def _login_user(self) -> None:
response = self._ok(
self.transport.request(
transport.HttpMethod.POST,
f"/login/{self._sudo_id}",
authenticator=lambda: {
"Authorization":
f"Bearer {self._get_admin_token().access_token}"
},
))
access_token = self.deserialize(data=response, structure=token_model)
assert isinstance(access_token, token_model_isinstances)
self.user_token = auth_token.AuthToken(access_token)
def __init__(
self,
settings: api_settings.PApiSettings,
transport: transport.Transport,
deserialize: serialize.TDeserialize,
version: str,
):
if not settings.is_configured():
raise error.SDKError(
"Missing required configuration values like base_url and api_version."
)
self.settings = settings
self.sudo_token: auth_token.AuthToken = auth_token.AuthToken()
self.token: auth_token.AuthToken = auth_token.AuthToken()
self._sudo_id: Optional[int] = None
self.transport = transport
self.deserialize = deserialize
self.version = version
self.token_model: Union[Type[models31.AccessToken], Type[models40.AccessToken]]
if self.version == "3.1":
self.token_model = models31.AccessToken
elif self.version == "4.0":
self.token_model = models40.AccessToken
def _login_sudo(self,
transport_options: transport.TransportOptions) -> None:
def authenticator(
transport_options: transport.TransportOptions, ) -> Dict[str, str]:
return {
"Authorization":
f"Bearer {self._get_token(transport_options).access_token}"
}
response = self._ok(
self.transport.request(
transport.HttpMethod.POST,
f"{self.settings.base_url}/api/{self.api_version}/login/{self._sudo_id}",
authenticator=authenticator,
transport_options=transport_options,
))
# ignore type: mypy bug doesn't recognized kwarg `structure` to partial func
access_token = self.deserialize(
data=response, structure=self.token_model) # type: ignore
assert isinstance(access_token, auth_token.AccessToken)
self.sudo_token = auth_token.AuthToken(access_token)
def _login_admin(self) -> None:
client_id = self.settings.get_client_id()
client_secret = self.settings.get_client_secret()
if not (client_id and client_secret):
raise error.SDKError("Required auth credentials not found.")
serialized = urllib.parse.urlencode({
"client_id":
cast(str, client_id),
"client_secret":
cast(str, client_secret),
}).encode("utf-8")
response = self._ok(
self.transport.request(
transport.HttpMethod.POST,
"/login",
body=serialized,
headers={"Content-Type": "application/x-www-form-urlencoded"},
))
access_token = self.deserialize(data=response, structure=token_model)
assert isinstance(access_token, token_model_isinstances)
self.admin_token = auth_token.AuthToken(access_token)
def _reset_admin_token(self) -> None:
self.admin_token = auth_token.AuthToken()
def _reset_user_token(self) -> None:
self.user_token = auth_token.AuthToken()
