#------------------------------------------------------------------
# Proxy Script Generated by Delphi Microservices Container 4.3.20
# Do not modify this code!
# Generated at: 2025-04-26 18.06.49
#------------------------------------------------------------------

import requests
import urllib3

urllib3.disable_warnings()

class AuthRPCException(Exception):
    pass

class AuthRPCProxy:
    def __init__(self, base_url):
        self.__id = 1
        self.base_url = base_url
        self.headers = {
            "content-type": "application/json",
            "accept": "application/json"
        }

    def __get_next_id(self):
        self.__id += 1
        return self.__id

    def __execute(self, req):
        isnotif = req.get("id") is None
        res = requests.post(self.base_url, json=req, headers=self.headers, verify=False)
        if res.status_code == 204:  # no content
            if isnotif:
              return None
            else:
              raise AuthRPCException(0,"Protocol error for Notification")
        if res.headers["content-type"].lower().find("application/json") != 0:
            raise AuthRPCException("Invalid ContentType in response: " + res.headers["content-type"])
        jres = res.json()
        if "error" in jres:
           raise AuthRPCException(jres.get("error").get("message"))
        if not "result" in jres:
            raise AuthRPCException(0,"Protocol error in JSON-RPC response - no result nor error node exists")
        return jres["result"]

    def __new_req(self, method, typ):
        req = dict(jsonrpc="2.0", method=method, params=[])
        if typ == "request":
           req["id"] = self.__get_next_id()
        return req
# end of library code

# Following methods are automatically generated

    def get_license_info(self, token):
        """
        Invokes [function GetLicenseInfo(const Token: string): TJsonObject]
        Returns all the info about the current license.
        """
        req = self.__new_req("GetLicenseInfo", "request")
        req["params"].append(token)
        result = self.__execute(req)
        return result

    def create_user(self, token, auser):
        """
        Invokes [function CreateUser(const Token: string; const aUser: TJsonObject): TJsonObject]
        """
        req = self.__new_req("CreateUser", "request")
        req["params"].append(token)
        req["params"].append(auser)
        result = self.__execute(req)
        return result

    def update_user(self, token, userid, auser):
        """
        Invokes [function UpdateUser(const Token: string; const UserID: Int64; const aUser: TJsonObject): TJsonObject]
        """
        req = self.__new_req("UpdateUser", "request")
        req["params"].append(token)
        req["params"].append(userid)
        req["params"].append(auser)
        result = self.__execute(req)
        return result

    def change_password(self, token, userid, newpassword) -> None:
        """
        Invokes [procedure ChangePassword(const Token: string; const UserID: Int64; const NewPassword: string)]
        """
        req = self.__new_req("ChangePassword", "notification")
        req["params"].append(token)
        req["params"].append(userid)
        req["params"].append(newpassword)
        result = self.__execute(req)
        return result

    def disable_user(self, token, userid) -> None:
        """
        Invokes [procedure DisableUser(const Token: string; const UserID: Int64)]
        """
        req = self.__new_req("DisableUser", "notification")
        req["params"].append(token)
        req["params"].append(userid)
        result = self.__execute(req)
        return result

    def enable_user(self, token, userid) -> None:
        """
        Invokes [procedure EnableUser(const Token: string; const UserID: Int64)]
        """
        req = self.__new_req("EnableUser", "notification")
        req["params"].append(token)
        req["params"].append(userid)
        result = self.__execute(req)
        return result

    def delete_user(self, token, userid) -> None:
        """
        Invokes [procedure DeleteUser(const Token: string; const UserID: Int64)]
        """
        req = self.__new_req("DeleteUser", "notification")
        req["params"].append(token)
        req["params"].append(userid)
        result = self.__execute(req)
        return result

    def delete_user_by_user_name(self, token, username):
        """
        Invokes [function DeleteUserByUserName(const Token: string; const UserName: string): TJsonObject]
        """
        req = self.__new_req("DeleteUserByUserName", "request")
        req["params"].append(token)
        req["params"].append(username)
        result = self.__execute(req)
        return result

    def get_user(self, token, userid):
        """
        Invokes [function GetUser(const Token: string; const UserID: Int64): TUser]
        """
        req = self.__new_req("GetUser", "request")
        req["params"].append(token)
        req["params"].append(userid)
        result = self.__execute(req)
        return result

    def get_users(self, token, filter):
        """
        Invokes [function GetUsers(const Token: string; const Filter: TJsonObject): TJsonObject]
        """
        req = self.__new_req("GetUsers", "request")
        req["params"].append(token)
        req["params"].append(filter)
        result = self.__execute(req)
        return result

    def get_audit(self, token, filter):
        """
        Invokes [function GetAudit(const Token: string; const Filter: TJsonObject): TJsonObject]
        """
        req = self.__new_req("GetAudit", "request")
        req["params"].append(token)
        req["params"].append(filter)
        result = self.__execute(req)
        return result

    def get_users_count(self, token, filter):
        """
        Invokes [function GetUsersCount(const Token: string; const Filter: TJsonObject): TJsonObject]
        """
        req = self.__new_req("GetUsersCount", "request")
        req["params"].append(token)
        req["params"].append(filter)
        result = self.__execute(req)
        return result

    def create_context(self, token, ssocontext):
        """
        Invokes [function CreateContext(const Token: string; const SSOContext: TJsonObject): TJsonObject]
        """
        req = self.__new_req("CreateContext", "request")
        req["params"].append(token)
        req["params"].append(ssocontext)
        result = self.__execute(req)
        return result

    def delete_context(self, token, ssocontextid) -> None:
        """
        Invokes [procedure DeleteContext(const Token: string; const SSOContextID: Int64)]
        """
        req = self.__new_req("DeleteContext", "notification")
        req["params"].append(token)
        req["params"].append(ssocontextid)
        result = self.__execute(req)
        return result

    def update_context(self, token, ssocontextid, ssocontext) -> None:
        """
        Invokes [procedure UpdateContext(const Token: string; const SSOContextID: Int64; const SSOContext: TJsonObject)]
        """
        req = self.__new_req("UpdateContext", "notification")
        req["params"].append(token)
        req["params"].append(ssocontextid)
        req["params"].append(ssocontext)
        result = self.__execute(req)
        return result

    def get_contexts(self, token, rqlfilter):
        """
        Invokes [function GetContexts(const Token: string; const RQLFilter: string): TJsonObject]
        """
        req = self.__new_req("GetContexts", "request")
        req["params"].append(token)
        req["params"].append(rqlfilter)
        result = self.__execute(req)
        return result

    def add_context_to_user(self, token, userid, usercontext):
        """
        Invokes [function AddContextToUser(const Token: string; const UserID: Int64; const UserContext: TJsonObject): TJsonObject]
        """
        req = self.__new_req("AddContextToUser", "request")
        req["params"].append(token)
        req["params"].append(userid)
        req["params"].append(usercontext)
        result = self.__execute(req)
        return result

    def update_context_to_user(self, token, usercontextid, usercontext) -> None:
        """
        Invokes [procedure UpdateContextToUser(const Token: string; const UserContextID: Int64; const UserContext: TJsonObject)]
        """
        req = self.__new_req("UpdateContextToUser", "notification")
        req["params"].append(token)
        req["params"].append(usercontextid)
        req["params"].append(usercontext)
        result = self.__execute(req)
        return result

    def get_user_context(self, token, usercontextid):
        """
        Invokes [function GetUserContext(const Token: string; const UserContextID: Int64): TJsonObject]
        Returns a single User-Context base on UserContextID
        """
        req = self.__new_req("GetUserContext", "request")
        req["params"].append(token)
        req["params"].append(usercontextid)
        result = self.__execute(req)
        return result

    def get_user_contexts(self, token, userid):
        """
        Invokes [function GetUserContexts(const Token: string; UserID: Int64): TJsonObject]
        Returns all User-Contexts by UserId
        """
        req = self.__new_req("GetUserContexts", "request")
        req["params"].append(token)
        req["params"].append(userid)
        result = self.__execute(req)
        return result

    def get_user_contexts_by_name(self, token, ssocontextname):
        """
        Invokes [function GetUserContextsByName(const Token: string; const SSOContextName: string): TJsonObject]
        Returns all User-Contexts by ContextName
        """
        req = self.__new_req("GetUserContextsByName", "request")
        req["params"].append(token)
        req["params"].append(ssocontextname)
        result = self.__execute(req)
        return result

    def get_available_contexts_for_user(self, token, userid):
        """
        Invokes [function GetAvailableContextsForUser(const Token: string; UserID: Int64): TJsonObject]
        Returns all Contexts not associated with UserID
        """
        req = self.__new_req("GetAvailableContextsForUser", "request")
        req["params"].append(token)
        req["params"].append(userid)
        result = self.__execute(req)
        return result

    def get_available_users_for_context(self, token, contextid):
        """
        Invokes [function GetAvailableUsersForContext(const Token: string; ContextID: Int64): TJsonObject]
        Returns all Users not associated with ContextID
        """
        req = self.__new_req("GetAvailableUsersForContext", "request")
        req["params"].append(token)
        req["params"].append(contextid)
        result = self.__execute(req)
        return result

    def delete_user_context(self, token, userid, ssocontextname) -> None:
        """
        Invokes [procedure DeleteUserContext(const Token: string; const UserID: Int64; const SSOContextName: string)]
        Removes the association between UserID and ContextName
        """
        req = self.__new_req("DeleteUserContext", "notification")
        req["params"].append(token)
        req["params"].append(userid)
        req["params"].append(ssocontextname)
        result = self.__execute(req)
        return result

    def get_all_my_context_info_by_context_name(self, token, ssocontextname):
        """
        Invokes [function GetAllMyContextInfoByContextName(const Token: string; SSOContextName: string): TJsonObject]
        """
        req = self.__new_req("GetAllMyContextInfoByContextName", "request")
        req["params"].append(token)
        req["params"].append(ssocontextname)
        result = self.__execute(req)
        return result

    def get_my_context_data_by_context_name(self, token, ssocontextname):
        """
        Invokes [function GetMyContextDataByContextName(const Token: string; SSOContextName: string): TJsonObject]
        """
        req = self.__new_req("GetMyContextDataByContextName", "request")
        req["params"].append(token)
        req["params"].append(ssocontextname)
        result = self.__execute(req)
        return result

    def get_my_system_data_by_context_name(self, token, ssocontextname):
        """
        Invokes [function GetMySystemDataByContextName(const Token: string; SSOContextName: string): TJsonObject]
        """
        req = self.__new_req("GetMySystemDataByContextName", "request")
        req["params"].append(token)
        req["params"].append(ssocontextname)
        result = self.__execute(req)
        return result

    def get_my_user_data_by_context_name(self, token, ssocontextname):
        """
        Invokes [function GetMyUserDataByContextName(const Token: string; SSOContextName: string): TJsonObject]
        """
        req = self.__new_req("GetMyUserDataByContextName", "request")
        req["params"].append(token)
        req["params"].append(ssocontextname)
        result = self.__execute(req)
        return result

    def set_my_user_data_by_context_name(self, token, ssocontextname, userdata) -> None:
        """
        Invokes [procedure SetMyUserDataByContextName(const Token: string; const SSOContextName: string; const UserData: TJsonObject)]
        """
        req = self.__new_req("SetMyUserDataByContextName", "notification")
        req["params"].append(token)
        req["params"].append(ssocontextname)
        req["params"].append(userdata)
        result = self.__execute(req)
        return result

    def get_current_api_key_for_user(self, token, userid):
        """
        Invokes [function GetCurrentAPIKeyForUser(const Token: string; const UserID: Int64): TJsonObject]
        """
        req = self.__new_req("GetCurrentAPIKeyForUser", "request")
        req["params"].append(token)
        req["params"].append(userid)
        result = self.__execute(req)
        return result

    def generate_api_key_for_user(self, token, userid):
        """
        Invokes [function GenerateAPIKeyForUser(const Token: string; const UserID: Int64): TJsonObject]
        """
        req = self.__new_req("GenerateAPIKeyForUser", "request")
        req["params"].append(token)
        req["params"].append(userid)
        result = self.__execute(req)
        return result

    def clear_api_key_for_user(self, token, userid) -> None:
        """
        Invokes [procedure ClearAPIKeyForUser(const Token: string; const UserID: Int64)]
        """
        req = self.__new_req("ClearAPIKeyForUser", "notification")
        req["params"].append(token)
        req["params"].append(userid)
        result = self.__execute(req)
        return result

    def login(self, username, password):
        """
        Invokes [function Login(const UserName: string; const Password: string): TJsonObject]
        Returns the JWT token which can be used to call all other methods.
        """
        req = self.__new_req("Login", "request")
        req["params"].append(username)
        req["params"].append(password)
        result = self.__execute(req)
        return result

    def refresh_token(self, token):
        """
        Invokes [function RefreshToken(const Token: string): TJsonObject]
        Extends the expiration time of a still-valid token. Clients must use the token returned instead of the previous one.
        """
        req = self.__new_req("RefreshToken", "request")
        req["params"].append(token)
        result = self.__execute(req)
        return result

# end of generated proxy