eclinical-requester 1.0.0__py3-none-any.whl

api_requester/dto/user.py

@@ -0,0 +1,39 @@
+# !/usr/bin/python3
+# -*- coding:utf-8 -*-
+"""
+@Author: xiaodong.li
+@Time: 03/18/2024 3:48 PM
+@Description: Description
+@File: authorize.py
+"""
+
+
+class EClinicalUser:
+
+    def __init__(self, username=None, password=None, sponsor=None, study=None, test_env=None, app_env=None, app=None,
+                 company=None, role=None, external=False):
+        # username 用户名
+        # password 密码
+        # app 访问的系统
+        # sponsor 访问sponsor 如果不需要，则传None
+        # study 访问sponsor 如果不需要，则传None
+        # test_env 访问的服务器环境
+        self.username = username
+        self.password = password
+        self.app = app
+        self.sponsor = sponsor
+        self.study = study
+        self.app_env = app_env
+        self.test_env = str(test_env)
+        self.company = company
+        self.role = role
+        self.external = external
+        self.company_level_login = False
+
+    def __repr__(self):
+        attributes = self.__dict__
+        info = list()
+        for item in ["test_env", "username", "role", "company", "sponsor", "study"]:
+            if attributes.get(item) is not None:
+                info.append(str(attributes.get(item)))
+        return "/".join(info)

api_requester/http/app_url.py

@@ -0,0 +1,31 @@
+# !/usr/bin/python3
+# -*- coding:utf-8 -*-
+"""
+@Author: xiaodong.li
+@Time: 7/24/2023 3:48 PM
+@Description: Description
+@File: app_url.py
+"""
+from api_requester.http.gateway import Gateway
+from api_requester.utils.constant import AppEnum
+
+
+class AppUrl(object):
+    def __init__(self, app, test_env):
+        self.app = app
+        self.test_env = test_env
+
+    def _app_url(self, api, app, external=False, **kwargs):
+        return Gateway(self.test_env).url(app, api, external).format(**kwargs)
+
+    def app_url(self, api, **kwargs):
+        return self._app_url(api, self.app, **kwargs)
+
+    def portal_url(self, api, **kwargs):
+        return self._app_url(api, AppEnum.ADMIN.code, **kwargs)
+
+    def external_url(self, api, **kwargs):
+        return self._app_url(api, self.app, True, **kwargs)
+
+    def which_url(self, app):
+        return self.portal_url if app == AppEnum.ADMIN.code else self.app_url

api_requester/http/authorize.py

@@ -0,0 +1,156 @@
+# !/usr/bin/python3
+# -*- coding:utf-8 -*-
+"""
+@Author: xiaodong.li
+@Time: 7/24/2023 3:48 PM
+@Description: Description
+@File: authorize.py
+"""
+import time
+
+from api_requester.core.admin.service.auth_service import AdminAuthService
+from api_requester.core.admin.service.impl.system_env_service_impl import CommonSystemEnvServiceImpl
+from api_requester.core.admin.service.impl.user_on_board_application_service_impl import \
+    AdminUserOnBoardApplicationServiceImpl
+from api_requester.dto.admin.cross_user_user_on_board_dto import CrossUserUserOnBoardDto
+from api_requester.dto.admin.jwt_authentication_request import JwtAuthenticationRequest
+from api_requester.dto.admin.user_on_board_dto import UserOnBoardDto
+from api_requester.dto.biz_base import BizBase
+from api_requester.dto.user import EClinicalUser
+from api_requester.http.sample_headers import SampleHeaders
+from api_requester.utils.constant import AppEnum, UserType
+from api_requester.utils.log import Logger
+from api_requester.utils.rsa import encrypt_password
+
+
+class Authorize(BizBase, SampleHeaders, AdminAuthService, AdminUserOnBoardApplicationServiceImpl,
+                CommonSystemEnvServiceImpl):
+
+    def __init__(self, user: EClinicalUser):
+        BizBase.__init__(self)
+        self.user = user
+        self.login_app = self.user.app
+        self.user.app = AppEnum.ADMIN.code
+        self.time_mills = time.time()
+        self.user_onboard_dto = UserOnBoardDto(-1)
+        SampleHeaders.__init__(self)
+        AdminAuthService.__init__(self)
+        AdminUserOnBoardApplicationServiceImpl.__init__(self)
+        CommonSystemEnvServiceImpl.__init__(self)
+
+    def login(self):
+        if self.login_app == AppEnum.CODING.code:
+            login_app_tip = "{0}({1})".format(self.login_app,
+                                              self.user.company_level_login is True and "admin" or "study")
+        else:
+            login_app_tip = self.login_app
+        try:
+            user_type = self._auth()
+            if user_type == UserType.account.type_name:
+                return
+            company_id = None
+            if self.user.company:
+                company_id = self.set_work_for_company_id()
+            if self.login_app != AppEnum.ADMIN.code:
+                self._user_onboard(company_id)
+                self.user.app = self.login_app
+                self._app_auth()
+                if self.user.role is not None:
+                    self.switch_role(self.user.role)
+            else:
+                self._entry_portal(company_id)
+            Logger().info("The user({0}) logs in to {1} successfully.".format(self.user, login_app_tip))
+        except Exception as e:
+            Logger().error("The user({0}) failed to log in to {1}.".format(self.user, login_app_tip))
+            raise Exception(f"Authorize Failed: {e}")
+
+    def _auth(self):
+        self.time_mills = time.time()
+        encrypt_pwd = encrypt_password(self.user.password)
+        jwt_authentication_request_dto = JwtAuthenticationRequest(self.user.username, encrypt_pwd)
+        response = self.create_authentication_token(jwt_authentication_request_dto)
+        if response is None:
+            raise Exception(f"LoginParams failed: {response}")
+        if response.get("jwtAuthenticationResponse") is None:
+            token = response.get("token")
+        else:
+            token = response.get("jwtAuthenticationResponse").get("token")
+        self.add_authorization(token)
+        self.time_mills = time.time()
+        return response.get("type")
+
+    def _user_onboard(self, company_id):
+        user_onboard_dto = UserOnBoardDto(-1)
+        user_onboard_dto.workForCompanyId = company_id
+        self._build_user_onboard_dto(user_onboard_dto)
+        self.user_onboard_dto = user_onboard_dto
+        response = self.on_board(user_onboard_dto)
+        self.add_authorization(response.get("token"))
+
+    def _build_user_onboard_dto(self, dto: UserOnBoardDto):
+        onboard_system_list = self.get_user_onboard_application_list(dto.workForCompanyId)
+        if not onboard_system_list:
+            raise Exception("Failed to obtain onboardSystemList info.")
+        for onboard_system in onboard_system_list:
+            if onboard_system.get("systemName").lower() == self.login_app:
+                dto.applicationId = onboard_system.get("systemId")
+                self._handle_onboard_envs(onboard_system, dto)
+                if self.user.company_level_login is True:
+                    dto.companyLevelLogin = True
+                    continue
+                onboard_sponsor_list = onboard_system.get("onboardSponsorList")
+                if not onboard_sponsor_list:
+                    continue
+                for onboard_sponsor in onboard_sponsor_list:
+                    if onboard_sponsor.get("name") == self.user.sponsor:
+                        dto.sponsorId = onboard_sponsor.get("sponsorId")
+                        self._handle_onboard_envs(onboard_sponsor, dto)
+                        onboard_study_list = onboard_sponsor.get("onboardStudyList")
+                        if not onboard_study_list:
+                            continue
+                        for onboard_study in onboard_study_list:
+                            if onboard_study.get("studyName") == self.user.study:
+                                dto.studyId = onboard_study.get("studyId")
+                                self._handle_onboard_envs(onboard_study, dto)
+        self._assert(self.login_app, dto.applicationId, "app")
+        if self.login_app in [AppEnum.EDC.code, AppEnum.DESIGN.code, AppEnum.IWRS.code, AppEnum.CODING.code]:
+            if dto.companyLevelLogin is False:
+                self._assert(self.user.study, dto.studyId, "study")
+            else:
+                self._assert(self.user.company, dto.workForCompanyId, "company")
+        elif self.login_app != AppEnum.ADMIN.code:
+            self._assert(self.user.sponsor, dto.sponsorId, "sponsor")
+        self._assert(self.user.app_env, dto.envId, "app env")
+
+    @staticmethod
+    def _assert(attr, att_id, k):
+        assert (not attr) or (False if att_id is None else True), f"Failed to obtain {k} id. {k}::{attr}."
+
+    def _handle_onboard_envs(self, onboard_infos, dto: UserOnBoardDto):
+        onboard_envs = onboard_infos.get("onboardEnvs") or list()
+        for onboardEnv in onboard_envs:
+            if onboardEnv.get("name") == self.user.app_env:
+                dto.envId = onboardEnv.get("id")
+
+    def set_work_for_company_id(self):
+        company_id = self.get_company_id(name=self.user.company)
+        if self.user.company and not company_id:
+            raise Exception("The company {0} was not found.".format(self.user.company))
+        return company_id
+
+    def _app_auth(self):
+        response = self.create_authentication_token()
+        if response.get("jwtAuthenticationResponse") is None:
+            token = response.get("token")
+        else:
+            token = response.get("jwtAuthenticationResponse").get("token")
+        self.add_authorization(token)
+        self.time_mills = time.time()
+
+    def _entry_portal(self, company_id):
+        response = self.login_portal(CrossUserUserOnBoardDto(companyId=company_id))
+        try:
+            token = response.get("token")
+            self.add_authorization(token)
+        except BaseException as e:
+            print(e)

api_requester/http/eclinical_requests.py

@@ -0,0 +1,264 @@
+"""
+@Author: xiaodong.li
+@Date: 2023-07-25 13:33:15
+LastEditors: xiaodong.li
+LastEditTime: 2023-07-25 13:33:15
+@Description: eclinical_requests.py
+"""
+import os
+import time
+from functools import wraps
+
+import requests
+from requests import Response
+from requests_toolbelt import MultipartEncoder
+
+from api_requester.dto.base_dto import BaseDto, build_file_dto
+from api_requester.dto.biz_base import BizBase
+from api_requester.http.app_url import AppUrl
+from api_requester.http.exceptions import ApiResponseException
+
+
+def get(api):
+    def __wrapper__(func):
+        @url(api)
+        @build_request_data()
+        @init_content_type()
+        @refresh_token()
+        @get_request()
+        @http_ok
+        def __inner__(instance: BizBase, *args, **kwargs):
+            return func(instance, *args, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def post(api):
+    def __wrapper__(func):
+        @url(api)
+        @build_request_data()
+        @init_content_type()
+        @refresh_token()
+        @post_request()
+        @http_ok
+        def __inner__(instance: BizBase, *args, **kwargs):
+            return func(instance, *args, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def delete(api):
+    def __wrapper__(func):
+        @url(api)
+        @build_request_data()
+        @init_content_type()
+        @refresh_token()
+        @delete_request()
+        @http_ok
+        def __inner__(instance: BizBase, *args, **kwargs):
+            return func(instance, *args, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def put(api):
+    def __wrapper__(func):
+        @url(api)
+        @build_request_data()
+        @init_content_type()
+        @refresh_token()
+        @put_request()
+        @http_ok
+        def __inner__(instance: BizBase, *args, **kwargs):
+            return func(instance, *args, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def get_request():
+    def __wrapper__(func):
+        def __inner__(instance: BizBase, **kwargs):
+            app_url = kwargs.pop("app_url")
+            rsp = requests.get(app_url, headers=instance.headers, **kwargs)
+            kwargs.update(rsp=rsp)
+            return func(instance, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def post_request():
+    def __wrapper__(func):
+        def __inner__(instance: BizBase, **kwargs):
+            app_url = kwargs.pop("app_url")
+            rsp = requests.post(app_url, headers=instance.headers, **kwargs)
+            kwargs.update(rsp=rsp)
+            return func(instance, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def delete_request():
+    def __wrapper__(func):
+        def __inner__(instance: BizBase, **kwargs):
+            app_url = kwargs.pop("app_url")
+            rsp = requests.delete(app_url, headers=instance.headers, **kwargs)
+            kwargs.update(rsp=rsp)
+            return func(instance, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def put_request():
+    def __wrapper__(func):
+        def __inner__(instance: BizBase, **kwargs):
+            app_url = kwargs.pop("app_url")
+            rsp = requests.put(app_url, headers=instance.headers, **kwargs)
+            kwargs.update(rsp=rsp)
+            return func(instance, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def url(api):
+    def __wrapper__(func):
+        def __inner__(instance: BizBase, *args, **kwargs):
+            url_kwargs = kwargs.pop("url_kwargs", {})
+            if instance.user.external is False:
+                app_url = AppUrl(instance.user.app, instance.user.test_env).which_url(
+                    instance.user.app)(api, **url_kwargs)
+            else:
+                app_url = AppUrl(instance.user.app, instance.user.test_env).external_url(api, **url_kwargs)
+            if app_url is None:
+                raise Exception("The url is null.")
+            kwargs.update(dict(app_url=app_url))
+            return func(instance, *args, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def build_request_data():
+    def __wrapper__(func):
+        def __inner__(instance: BizBase, *args, **kwargs):
+            for key in ["json", "params"]:
+                value = kwargs.get(key)
+                if value is not None:
+                    if issubclass(value.__class__, BaseDto):
+                        kwargs[key] = value.to_dict()
+                    elif isinstance(value, list):
+                        kwargs[key] = [i.to_dict() if issubclass(i.__class__, BaseDto) else i for i in value]
+                    elif isinstance(value, dict):
+                        if key == "params":
+                            base_dto_keys = [k for k, v in value.items() if issubclass(v.__class__, BaseDto)]
+                            if len(base_dto_keys) > 0:
+                                base_dto_dict = dict()
+                                for k in base_dto_keys:
+                                    dto_dict = value.pop(k).to_dict()
+                                    if dto_dict.keys() & base_dto_dict:
+                                        raise Exception("Duplicate keys found in BaseDto dictionaries")
+                                    base_dto_dict.update(dto_dict)
+                                if base_dto_dict.keys() & value:
+                                    raise Exception("BaseDto keys overlap with non-BaseDto keys")
+                                value.update(base_dto_dict)
+                        else:
+                            kwargs[key] = {k: v.to_dict() if issubclass(v.__class__, BaseDto) else v for k, v in
+                                           value.items()}
+            data = kwargs.get("data")
+            if data is None and "multipart_encoder_kwargs" in kwargs:
+                multipart_encoder_kwargs = kwargs.pop("multipart_encoder_kwargs")
+                if multipart_encoder_kwargs is not None:
+                    multipart_encoder_data = list()
+                    for k, v in multipart_encoder_kwargs.items():
+                        if issubclass(v.__class__, BaseDto):
+                            multipart_encoder_data.extend(v.build_multipart_fields(values_as_str=True, has_none=False))
+                        elif isinstance(v, list) and all(
+                                isinstance(file, str) and os.path.exists(file) and os.path.isfile(file) for file in v):
+                            multipart_encoder_data.extend([(k, build_file_dto(file)) for file in v])
+                        elif isinstance(v, str) and os.path.exists(v) and os.path.isfile(v):
+                            multipart_encoder_data.append((k, build_file_dto(v)))
+                        else:
+                            multipart_encoder_data.append((k, v))
+                    if len(multipart_encoder_data) > 0:
+                        data = MultipartEncoder(fields=multipart_encoder_data)
+                kwargs.update(dict(data=data))
+            return func(instance, *args, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def init_content_type():
+    def __wrapper__(func):
+        def __inner__(instance: BizBase, *args, **kwargs):
+            if instance.refresh_content_type is True:
+                instance.headers.update({"Content-Type": "application/json"})
+            data = kwargs.get("data")
+            if isinstance(data, MultipartEncoder):
+                instance.headers.update({"Content-Type": data.content_type})
+            return func(instance, *args, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def refresh_token():
+    def __wrapper__(func):
+        def __inner__(instance: BizBase, *args, **kwargs):
+            instance.user.external is False and (
+                    int(time.time() - instance.time_mills) < 60 * 30 - 300 or instance.login())
+            return func(instance, *args, **kwargs)
+
+        return __inner__
+
+    return __wrapper__
+
+
+def http_ok(func):
+    @wraps(func)
+    def _http_ok(instance: BizBase, **kwargs):
+        try:
+            rsp: Response = kwargs.pop("rsp")
+            instance.last_kwargs = kwargs
+            instance.last_result = rsp
+            content_type = rsp.headers.get("content-type")
+            if rsp.status_code not in [200, 201]:
+                raise ApiResponseException(rsp)
+            if not content_type:
+                raise ApiResponseException(rsp, message="The content-type in the response header is empty.")
+            if "application/json" in content_type:
+                proc_code = rsp.json().get("procCode")
+                if proc_code not in [200, 201]:
+                    raise ApiResponseException(rsp)
+                else:
+                    return rsp.json().get("payload")
+            elif any(item in content_type for item in ["application/octet-stream", "application/vnd.ms-excel"]):
+                return rsp.content
+            else:
+                raise ApiResponseException(rsp, message="Please handle the {0} request.".format(content_type))
+        except Exception as e:
+            if instance.raises_exception is True:
+                raise
+            else:
+                # Handle non-exception case here if necessary
+                print(f"Exception caught but not re-raised: {e}")
+
+    return _http_ok

api_requester/http/exceptions.py

@@ -0,0 +1,72 @@
+# !/usr/bin/python3
+# -*- coding:utf-8 -*-
+"""
+@Author: xiaodong.li
+@Time: 8/5/2024 4:35 PM
+@Description: Description
+@File: exceptions.py
+"""
+from urllib.parse import urlparse
+
+from requests import Response
+
+
+class ApiResponseException(Exception):
+    def __init__(self, response: Response, message=None, exception=None, request_payload=None):
+        self.status_code = response.status_code
+        self.api = urlparse(response.url).path
+        self.method = response.request.method
+        self.message = message
+        self.exception = exception
+        self.request_payload = request_payload
+        self.proc_code = None
+        content_type = response.headers.get("content-type")
+        if not content_type:
+            ...
+        elif "application/json" in content_type:
+            self.proc_code = response.json().get("procCode")
+            self.message = response.json().get("message") or message
+            self.exception = response.json().get("exception") or exception
+        else:
+            self.message = "\n".join([message, response.text])  if message else response.text
+
+    def __str__(self):
+        messages = [
+            "\nRequest response exception:",
+            "Status code: {0}".format(self.status_code),
+            "URL: {0} {1}".format(self.method, self.api),
+        ]
+        if self.request_payload:
+            if isinstance(self.request_payload, dict):
+                payload = "\n".join(["{0}: {1}".format(k, v) for k, v in self.request_payload.items()])
+            else:
+                payload = str(self.request_payload)
+            messages.append("Request payload: {0}".format(payload))
+        if self.proc_code:
+            messages.append("Proc code: {0}".format(self.proc_code))
+        if self.message:
+            messages.append("Message: {0}".format(self.message))
+        if self.exception:
+            messages.append("Exception: {0}".format(self.exception))
+        return "\n".join(messages)
+
+
+class ApiValidationError(ApiResponseException):
+    """自定义异常类，用于验证接口失败时引发错误"""
+
+    def __init__(self, response: Response, message=None, exception=None, request_payload=None):
+        super().__init__(response, message, exception, request_payload)
+
+
+class DatabaseValidationError(Exception):
+    """自定义异常类，用于数据库验证失败时引发错误"""
+
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class FileValidationError(Exception):
+    """自定义异常类，用于文件验证失败时引发错误"""
+
+    def __init__(self, message):
+        super().__init__(message)

api_requester/http/gateway.py

@@ -0,0 +1,105 @@
+# !/usr/bin/python3
+# -*- coding:utf-8 -*-
+"""
+@Author: xiaodong.li
+@Time: 7/24/2023 3:48 PM
+@Description: Description
+@File: gateway.py
+"""
+import os.path
+import re
+from urllib.parse import urlparse
+
+from requests.structures import LookupDict
+
+from api_requester.utils.constant import AppEnum
+from api_requester.utils.path import docs_path
+from api_requester.utils.read_file import connect_to
+
+_api = {
+    AppEnum.ADMIN.code: (AppEnum.ADMIN.code,),
+    AppEnum.EDC.code: (AppEnum.EDC.code,),
+    AppEnum.CTMS.code: (AppEnum.CTMS.code,),
+    AppEnum.ETMF.code: (AppEnum.ETMF.code,),
+    AppEnum.DESIGN.code: ('designer', AppEnum.DESIGN.code),
+    AppEnum.IWRS.code: (AppEnum.IWRS.code,),
+    "external": ('external',),
+    AppEnum.CODING.code: (AppEnum.CODING.code,),
+    AppEnum.IMAGING.code: (AppEnum.IMAGING.code,),
+    AppEnum.PV.code: (AppEnum.PV.code,),
+}
+apis = LookupDict(name='api')
+
+
+def _init():
+    for app_api, apps in _api.items():
+        for app in apps:
+            setattr(apis, app, app_api)
+
+
+_init()
+
+
+class Gateway(object):
+    def __init__(self, test_env):
+        self.test_env = test_env
+        yaml_path = os.path.join(docs_path(), "application.yaml")
+        self.api_yaml = connect_to(yaml_path).data
+
+    def _url(self, app_api, api, external=False):
+        server_url = self._server_url(app_api)
+        api_url = self._ex_domain(app_api, api) or self._in_domain(app_api, api, external)
+        return "{0}{1}".format(server_url, api_url)
+
+    def _server_url(self, app_api):
+        server_url_mapping = self.api_yaml["serverUrl"]
+        server_url = server_url_mapping.get(self.test_env)
+        if server_url is not None:
+            return server_url
+        else:
+            postfix = dict(portal_api=".admin", ctms_api=".ctms", designer_api=".designer",
+                           etmf_api=".etmf", edc_api=".edc", iwrs_api=".iwrs").get(app_api)
+            return server_url_mapping.get("{0}{1}".format(self.test_env, postfix))
+
+    def _in_domain(self, app_api, api, external=False):
+        domain = self.api_yaml.get(app_api).get("urlPrefix")
+        api_url = self._disposed(app_api, api) or self._not_disposed(api)
+        return api_url if (external and domain in api_url) else "{0}{1}".format(domain, api_url)
+
+    def _ex_domain(self, app_api, api):
+        api_url = self._disposed(app_api, api) or self._not_disposed(api)
+        if "local" in self.test_env:
+            return api_url
+        return None
+
+    def _disposed(self, app_api, api):
+        return self.api_yaml.get(app_api).get(api)
+
+    @staticmethod
+    def _not_disposed(api):
+        return api
+
+    @staticmethod
+    def get_app_api(app):
+        return eval(f"apis.{app.lower()}")
+
+    def url(self, app, api, external=False):
+        # if external:  # s3前端迁移
+        #     self.test_env = f"{self.test_env}.external"
+        tmp_url = self._url(self.get_app_api(external is False and app or "external"), api, external)
+        return self.rewrite_path(app, tmp_url)
+
+    def netloc(self, app):
+        server_url = self._server_url(self.get_app_api(app))
+        return urlparse(server_url).netloc
+
+    def rewrite_path(self, app, api):
+        app_config = self.api_yaml.get(app)
+        filters = app_config.get("filters")
+        if filters is not None:
+            for item in filters:
+                if item.startswith("RewritePath="):
+                    item = item.replace("RewritePath=", "")
+                    rewrite_rule, target = item.split(",")
+                    api = re.sub(rewrite_rule, target, api)
+        return api

api_requester/http/sample_headers.py

@@ -0,0 +1,23 @@
+# !/usr/bin/python3
+# -*- coding:utf-8 -*-
+"""
+@Author: xiaodong.li
+@Time: 7/24/2023 3:48 PM
+@Description: Description
+@File: sample_headers.py
+"""
+
+
+class SampleHeaders(object):
+    def __init__(self):
+        self.headers = {"Content-Type": "application/json", "Connection": "close"}
+
+    def add_header(self, **kwargs):
+        self.headers.update(kwargs)
+        return self
+
+    def to_h(self):
+        return self.headers
+
+    def add_authorization(self, token):
+        return self.add_header(Authorization=token)