def request_dto_serialize(): dto = RequestDto[ComputerFlow]("some_method", ComputerFlow.get_random_flow()) json_dto = JsonFormatter.serialize(dto) dto_value = JsonFormatter.deserialize(json_dto, RequestDto[ComputerFlow]) print(dto_value) # repeat json_dto2 = JsonFormatter.serialize(dto_value) dto_value2 = JsonFormatter.deserialize(json_dto2, RequestDto[ComputerFlow]) print(dto_value2 ) # needed for breakpoint to check the result of formatting
def request_dto_computer_key(): dto0 = RequestDto[ComputerKey](data=ComputerKey("5", "40")) json0 = JsonFormatter.serialize(dto0) val0 = JsonFormatter.deserialize(json0, RequestDto[ComputerKey]) print(val0) print(RequestDto.__annotations__["data"]) dto1 = RequestDto[ComputerManager.GetKeysByAuditoriumDto]( data=ComputerManager.GetKeysByAuditoriumDto("37")) json1 = JsonFormatter.serialize(dto1) val1 = JsonFormatter.deserialize( json1, RequestDto[ComputerManager.GetKeysByAuditoriumDto]) print(val1) print(RequestDto.__annotations__["data"])
def __read_from_config(cls) -> Union[UrlInfo, None]: if os.path.exists(cls.__file_name): with open(cls.__file_name) as file: json = file.read() if len(json) > 0: return JsonFormatter.deserialize(json, UrlInfo) return None
def __read_temp_data(cls) -> ComputerFlow: temp_data: str = "" if os.path.exists(cls.__temp_data_file): with open(cls.__temp_data_file, "r") as file: temp_data = file.read() return JsonFormatter.deserialize( temp_data, ComputerFlow) if temp_data else ComputerFlow()
def __set_config_impl(cls, web_config: ClientConfig) -> bool: if not hasattr(web_config, "check_state_period") or not hasattr(web_config, "send_data_period"): raise ServerLogicException(401, "Received wrong data from client !") if ConfigManager.__validate_config(web_config): with open(cls.__file_name, "w") as config_file: config_file.write(JsonFormatter.serialize(web_config)) return True return False
def get_request_dto(self, json_request_dto: str, method_name: str, client_address: Tuple[str, int]) -> BaseRequestDto: dto_type = self.__get_request_type(method_name) request_dto = JsonFormatter.deserialize(json_request_dto, dto_type) if not hasattr(request_dto, "data"): raise ServerLogicException( 400, f"Server work only with dto types ! Stop spam !") UrlManager.resolve_client_address(request_dto, client_address) return request_dto
def send_wrong_dto(): # wrong dto. Might be RequestDto[ComputerKey] dto = RequestDto[GetKeysByAuditoriumDto]( data=GetKeysByAuditoriumDto("39")) json = JsonFormatter.serialize(dto) result = NetworkManager.send("GetComputer", json) print(result) json_dto = '{"d": {"a": 3}}' # type value of "a" might be a string result2 = NetworkManager.send("GetComputer", json_dto) print(result2)
def read_all(self) -> List[Computer]: if len(self.__cache) == super().count(): return [*self.__cache.values()] read_all_result = super().read_all() computers = [] for name, auditorium, json_data in read_all_result: computer: Computer = JsonFormatter.deserialize(json_data, Computer) self.__cache[ComputerKey(name, auditorium)] = computer computers.append(computer) return computers
def use_unsupported_server_method(): # GET request result = NetworkManager.get("GetAuditor") print(result) # POST request dto = RequestDto[GetKeysByAuditoriumDto]( data=GetKeysByAuditoriumDto("39")) json = JsonFormatter.serialize(dto) result = NetworkManager.send("GetKeysByAuditori", json) print(result)
def read(self, key: ComputerKey) -> Union[Computer, None]: computer = self.__cache.get(key) if computer is not None: return computer *_, value = super().read(key) or (None, None) if value is not None: computer = JsonFormatter.deserialize(value, Computer) self.__cache[key] = computer return computer return None
def __read_config_from_file(file_name: str) -> ClientConfig: if os.path.exists(file_name): with open(file_name, "r") as file: file_content = file.read() else: raise Exception(f"Can not open file with Client config (file: {file_name})") if file_content: config = JsonFormatter.deserialize(file_content, ClientConfig) if ConfigManager.__validate_config(config): return config raise Exception(f"Client config in {file_name} is invalid, check the file")
def do_GET(self): method_name = MethodHandler.get_server_method_name(self.path) try: response_dto = HttpRequestHandler.method_handler.do_get( method_name) except ServerLogicException as ex: self.send_error(ex.state_code, ex.message) return self.send_response(response_dto.state_code) self.__send_header() response_dto_json = JsonFormatter.serialize(response_dto) self.wfile.write(response_dto_json.encode())
def do_POST(self): length: int = int(self.headers.get('content-length', 0)) json_request_dto: str = self.rfile.read(length).decode("utf-8") method_name = MethodHandler.get_server_method_name(self.path) try: request_dto = HttpRequestHandler.method_handler.get_request_dto( json_request_dto, method_name, self.client_address) response_dto = HttpRequestHandler.method_handler.do_post( method_name, request_dto) except ServerLogicException as ex: self.send_error(ex.state_code, ex.message) return response_dto_json = JsonFormatter.serialize(response_dto) self.send_response(response_dto.state_code) self.__send_header() self.wfile.write(response_dto_json.encode())
def dict_field_serialize(): some_type = SomeType.get_random_some_type() json = JsonFormatter.serialize(some_type) val = JsonFormatter.deserialize(json, SomeType) print(val)
def request_complex_dto_serialize(): dto = SomeEntity.get_temp_some_entity() json_dto = JsonFormatter.serialize(dto) dto_val = JsonFormatter.deserialize(json_dto, SomeEntity) print(dto_val)
def computer_flow_serialize(): computer_flow = ComputerFlow.get_random_flow() computer_flow_json = JsonFormatter.serialize(computer_flow) val = JsonFormatter.deserialize(computer_flow_json, ComputerFlow) print(val)
def get_keys_by_auditorium(): dto = RequestDto[GetKeysByAuditoriumDto]( data=GetKeysByAuditoriumDto("39")) json = JsonFormatter.serialize(dto) result = NetworkManager.send("GetKeysByAuditorium", json) print(result)
def serialize_test(): person: Person = Person(13, "Max") json = JsonFormatter.serialize(person) person_val = JsonFormatter.deserialize(json, Person) print(person_val)
def computer_serialize(): computer = Computer.get_random_computer() json = JsonFormatter.serialize(computer) val = JsonFormatter.deserialize(json, Computer) print(val)
def client_config(): c = ClientConfig(None, None) json = JsonFormatter.serialize(c) val = JsonFormatter.deserialize(json, ClientConfig) print(val.__dict__) print(val)
def update(self, key: ComputerKey, computer: Computer) -> None: self.__cache[key] = computer json_data = JsonFormatter.serialize(computer) super().update(key, json_data)
def __send_data_to_server_impl(computer_flow: ComputerFlow): dto = RequestDto[ComputerFlow](data=computer_flow) dto_json = JsonFormatter.serialize(dto) NetworkManager.send("SendComputerFlow", dto_json)
def __store_temp_data(cls, data) -> None: with open(cls.__temp_data_file, "w") as temp_data_file: temp_data_file.write(JsonFormatter.serialize(data))
def __read_keys_from_file(cls): if os.path.exists(cls.__file_name): with open(cls.__file_name, "r") as file: keys = file.read() return JsonFormatter.deserialize( keys, ComputerKeysData) if keys else None
def __read_from_server() -> Union[ClientConfig, None]: json: str = NetworkManager.get("GetClientConfig") return JsonFormatter.deserialize( json, ResponseDto[ClientConfig]).data if json else None