def orm_to_dto(orm_object): # type: (EepromModel) -> PumpGroupDTO data = orm_object.serialize() kwargs = {'pump_output_id': Toolbox.nonify(data['output'], PumpGroupMapper.BYTE_MAX), 'valve_output_ids': ([int(output_id) for output_id in data['outputs'].split(',')] if data['outputs'] != '' else []), 'room_id': Toolbox.nonify(data['room'], PumpGroupMapper.BYTE_MAX)} return PumpGroupDTO(id=data['id'], **kwargs)
def orm_to_dto(orm_object): # type: (EepromModel) -> ShutterDTO data = orm_object.serialize() kwargs = {} for field in ['timer_up', 'timer_down', 'up_down_config', 'group_1', 'group_2']: kwargs[field] = Toolbox.nonify(data[field], ShutterMapper.BYTE_MAX) for field in ['steps']: kwargs[field] = Toolbox.nonify(data[field], ShutterMapper.WORD_MAX) return ShutterDTO(id=data['id'], name=data['name'], **kwargs)
def orm_to_dto(orm_object): # type: (EepromModel) -> GlobalFeedbackDTO data = orm_object.serialize() return GlobalFeedbackDTO(id=data['id'], can_led_1=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_1_id'], GlobalFeedbackMapper.BYTE_MAX), function=data['can_led_1_function']), can_led_2=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_2_id'], GlobalFeedbackMapper.BYTE_MAX), function=data['can_led_2_function']), can_led_3=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_3_id'], GlobalFeedbackMapper.BYTE_MAX), function=data['can_led_3_function']), can_led_4=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_4_id'], GlobalFeedbackMapper.BYTE_MAX), function=data['can_led_4_function']))
def deserialize(api_data): # type: (Dict[str,Any]) -> VentilationStatusDTO status_dto = VentilationStatusDTO(id=api_data['id'], mode=api_data['mode']) if 'level' in api_data: status_dto.level = Toolbox.nonify(api_data['level'], 0) if 'timer' in api_data: status_dto.timer = Toolbox.nonify(api_data['timer'], 0) if 'remaining_time' in api_data: status_dto.remaining_time = Toolbox.nonify( api_data['remaining_time'], 0) return status_dto
def deserialize(api_data): # type: (Dict[str,Any]) -> Tuple[VentilationStatusDTO, List[str]] loaded_fields = ['id', 'mode'] status_dto = VentilationStatusDTO(api_data['id'], api_data['mode']) if 'level' in api_data: loaded_fields.append('level') status_dto.level = Toolbox.nonify(api_data['level'], 0) if 'timer' in api_data: loaded_fields.append('timer') status_dto.timer = Toolbox.nonify(api_data['timer'], 0) if 'remaining_time' in api_data: loaded_fields.append('remaining_time') status_dto.remaining_time = Toolbox.nonify( api_data['remaining_time'], 0) return status_dto, loaded_fields
def deserialize(api_data): # type: (Dict) -> OutputDTO output_dto = OutputDTO(api_data['id']) SerializerToolbox.deserialize( dto=output_dto, # Referenced api_data=api_data, mapping={ 'module_type': ('module_type', None), 'name': ('name', None), 'type': ('output_type', None), 'lock_bit_id': ('lock_bit_id', OutputSerializer.BYTE_MAX), 'timer': ('timer', OutputSerializer.WORD_MAX), 'floor': ('floor', OutputSerializer.BYTE_MAX), 'room': ('room', OutputSerializer.BYTE_MAX) }) for i in range(4): base_field = 'can_led_{0}'.format(i + 1) id_field = '{0}_id'.format(base_field) function_field = '{0}_function'.format(base_field) if id_field in api_data and function_field in api_data: setattr( output_dto, base_field, FeedbackLedDTO(id=Toolbox.nonify( api_data[id_field], OutputSerializer.BYTE_MAX), function=api_data[function_field])) return output_dto
def orm_to_dto(orm_object): # type: (EepromModel) -> ThermostatDTO data = orm_object.serialize() kwargs = { 'name': data['name'], 'permanent_manual': data['permanent_manual'] } for i in range(6): field = 'setp{0}'.format(i) kwargs[field] = data[field] for field in [ 'sensor', 'output0', 'output1', 'pid_p', 'pid_i', 'pid_d', 'pid_int', 'room' ]: kwargs[field] = Toolbox.nonify(data[field], ThermostatMapper.BYTE_MAX) for day in ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']: field = 'auto_{0}'.format(day) kwargs[field] = ThermostatScheduleDTO(temp_night=data[field][0], start_day_1=data[field][1], end_day_1=data[field][2], temp_day_1=data[field][3], start_day_2=data[field][4], end_day_2=data[field][5], temp_day_2=data[field][6]) return ThermostatDTO(id=data['id'], **kwargs)
def _publish_shutter_change(self, shutter_id, shutter_data, shutter_state): # type: (int, ShutterDTO, Tuple[float, str]) -> None gateway_event = GatewayEvent(event_type=GatewayEvent.Types.SHUTTER_CHANGE, data={'id': shutter_id, 'status': {'state': shutter_state[1].upper(), 'last_change': shutter_state[0]}, 'location': {'room_id': Toolbox.nonify(shutter_data.room, 255)}}) self._pubsub.publish_gateway_event(PubSub.GatewayTopics.STATE, gateway_event)
def deserialize( api_data): # type: (Dict) -> Tuple[ThermostatGroupDTO, List[str]] loaded_fields = [] thermostat_group_dto = ThermostatGroupDTO(id=0) loaded_fields += SerializerToolbox.deserialize( dto=thermostat_group_dto, # Referenced api_data=api_data, mapping={ 'outside_sensor': ('outside_sensor_id', ThermostatGroupSerializer.BYTE_MAX), 'threshold_temp': ('threshold_temperature', ThermostatGroupSerializer.BYTE_MAX), 'pump_delay': ('pump_delay', ThermostatGroupSerializer.BYTE_MAX) }) for mode in ['heating', 'cooling']: for i in range(4): output_field = 'switch_to_{0}_output_{1}'.format(mode, i) value_field = 'switch_to_{0}_value_{1}'.format(mode, i) dto_field = 'switch_to_{0}_{1}'.format(mode, i) if output_field in api_data and value_field in api_data: loaded_fields.append(dto_field) output = Toolbox.nonify(api_data[output_field], ThermostatGroupSerializer.BYTE_MAX) value = api_data[value_field] if output is None: setattr(thermostat_group_dto, dto_field, None) else: setattr(thermostat_group_dto, dto_field, [output, value]) return thermostat_group_dto, loaded_fields
def orm_to_dto(orm_object): # type: (EepromModel) -> ShutterGroupDTO data = orm_object.serialize() kwargs = {} for field in ['timer_up', 'timer_down']: kwargs[field] = Toolbox.nonify(data[field], ShutterGroupMapper.BYTE_MAX) return ShutterGroupDTO(id=data['id'], **kwargs)
def orm_to_dto(orm_object): # type: (EepromModel) -> PulseCounterDTO data = orm_object.serialize() return PulseCounterDTO(id=data['id'], name=data['name'], input_id=Toolbox.nonify( data['input'], PulseCounterMapper.BYTE_MAX), persistent=False)
def orm_to_dto(orm_object): # type: (EepromModel) -> ThermostatGroupDTO data = orm_object.serialize() kwargs = {} for dto_field, orm_field in {'outside_sensor_id': 'outside_sensor', 'threshold_temperature': 'threshold_temp', 'pump_delay': 'pump_delay'}.items(): kwargs[dto_field] = Toolbox.nonify(data[orm_field], ThermostatGroupMapper.BYTE_MAX) for mode in ['heating', 'cooling']: for i in range(4): output_field = 'switch_to_{0}_output_{1}'.format(mode, i) value_field = 'switch_to_{0}_value_{1}'.format(mode, i) dto_field = 'switch_to_{0}_{1}'.format(mode, i) output = Toolbox.nonify(data[output_field], ThermostatGroupMapper.BYTE_MAX) value = Toolbox.nonify(data[value_field], ThermostatGroupMapper.BYTE_MAX) if output is not None: kwargs[dto_field] = [output, value] return ThermostatGroupDTO(id=0, **kwargs)
def deserialize(api_data): # type: (Dict) -> RoomDTO room_dto = RoomDTO(id=api_data['id']) if 'name' in api_data: room_dto.name = Toolbox.nonify(api_data['name'], '') if 'floor' in api_data: floor_id = api_data['floor'] if floor_id != 255: room_dto.floor = FloorDTO(id=floor_id) return room_dto
def deserialize(dto, api_data, mapping): for data_field, (dto_field, default) in mapping.items(): if data_field in api_data: if default is None: setattr(dto, dto_field, api_data[data_field]) elif callable(default): setattr(dto, dto_field, default(api_data[data_field])) else: setattr(dto, dto_field, Toolbox.nonify(api_data[data_field], default))
def orm_to_dto(orm_object): # type: (EepromModel) -> InputDTO data = orm_object.serialize() return InputDTO(id=data['id'], module_type=data['module_type'], name=data['name'], action=Toolbox.nonify(data['action'], InputMapper.BYTE_MAX), basic_actions=[] if data['basic_actions'] == '' else [int(i) for i in data['basic_actions'].split(',')], invert=data['invert'] != 255, can=data['can'] == 'C')
def orm_to_dto(orm_object): # type: (EepromModel) -> RTD10DTO data = orm_object.serialize() kwargs = {} for field in [ 'temp_setpoint_output', 'ventilation_speed_output', 'ventilation_speed_value', 'mode_output', 'mode_value', 'on_off_output', 'poke_angle_output', 'poke_angle_value', 'room' ]: kwargs[field] = Toolbox.nonify(data[field], RTD10Mapper.BYTE_MAX) return RTD10DTO(id=data['id'], **kwargs)
def deserialize(api_data): # type: (Dict) -> Tuple[RoomDTO, List[str]] loaded_fields = ['id'] room_dto = RoomDTO(id=api_data['id']) if 'name' in api_data: loaded_fields.append('name') room_dto.name = Toolbox.nonify(api_data['name'], '') if 'floor' in api_data: loaded_fields.append('floor') floor_id = api_data['floor'] if floor_id != 255: room_dto.floor = FloorDTO(id=floor_id) return room_dto, loaded_fields
def deserialize(api_data): # type: (Dict[str,Any]) -> VentilationDTO ventilation_id = None # type: Optional[int] if 'id' in api_data: ventilation_id = api_data['id'] source_dto = None # type: Optional[VentilationSourceDTO] if 'source' in api_data: source_dto = VentilationSourceDTO(None, name=api_data['source']['name'], type=api_data['source']['type']) ventilation_dto = VentilationDTO(id=ventilation_id, source=source_dto) if 'external_id' in api_data: ventilation_dto.external_id = Toolbox.nonify( api_data['external_id'], '') if 'name' in api_data: ventilation_dto.name = Toolbox.nonify(api_data['name'], '') if 'amount_of_levels' in api_data: ventilation_dto.amount_of_levels = Toolbox.nonify( api_data['amount_of_levels'], '') if 'device' in api_data: if 'type' in api_data['device']: ventilation_dto.device_type = Toolbox.nonify( api_data['device']['type'], '') if 'vendor' in api_data['device']: ventilation_dto.device_vendor = Toolbox.nonify( api_data['device']['vendor'], '') if 'serial' in api_data['device']: ventilation_dto.device_serial = Toolbox.nonify( api_data['device']['serial'], '') return ventilation_dto
def deserialize(api_data): # type: (Dict) -> GlobalFeedbackDTO global_feedback_dto = GlobalFeedbackDTO(api_data['id']) for i in range(4): base_field = 'can_led_{0}'.format(i + 1) id_field = '{0}_id'.format(base_field) function_field = '{0}_function'.format(base_field) if id_field in api_data and function_field in api_data: setattr( global_feedback_dto, base_field, FeedbackLedDTO(id=Toolbox.nonify( api_data[id_field], GlobalFeedbackSerializer.BYTE_MAX), function=api_data[function_field])) return global_feedback_dto
def deserialize(dto, api_data, mapping): loaded_fields = [] for data_field, (dto_field, default) in mapping.items(): if data_field in api_data: loaded_fields.append(dto_field) if default is None: setattr(dto, dto_field, api_data[data_field]) elif callable(default): setattr(dto, dto_field, default(api_data[data_field])) else: setattr(dto, dto_field, Toolbox.nonify(api_data[data_field], default)) return loaded_fields
def orm_to_dto(orm_object): # type: (ShutterConfiguration) -> ShutterDTO kwargs = {} for field in ['timer_up', 'timer_down']: kwargs[field] = Toolbox.nonify(getattr(orm_object, field), ShutterMapper.WORD_MAX) if kwargs[field] is not None: # TODO: High-level code currently assumes this is a byte kwargs[field] = min(ShutterMapper.BYTE_MAX, kwargs[field] // 10) member_groups = [] for group_id in range(16): if getattr(orm_object.groups, 'group_{0}'.format(group_id)): member_groups.append(group_id) if len(member_groups) >= 1: kwargs['group_1'] = member_groups[0] if len(member_groups) >= 2: kwargs['group_2'] = member_groups[1] return ShutterDTO(id=orm_object.id, name=orm_object.name, **kwargs)
def orm_to_dto(orm_object): # type: (EepromModel) -> OutputDTO data = orm_object.serialize() return OutputDTO( id=data['id'], module_type=data['module_type'], name=data['name'], timer=Toolbox.nonify(data['timer'], OutputMapper.WORD_MAX), floor=Toolbox.nonify(data['floor'], OutputMapper.BYTE_MAX), output_type=data['type'], lock_bit_id=Toolbox.nonify(data['lock_bit_id'], OutputMapper.BYTE_MAX), can_led_1=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_1_id'], OutputMapper.BYTE_MAX), function=data['can_led_1_function']), can_led_2=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_2_id'], OutputMapper.BYTE_MAX), function=data['can_led_2_function']), can_led_3=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_3_id'], OutputMapper.BYTE_MAX), function=data['can_led_3_function']), can_led_4=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_4_id'], OutputMapper.BYTE_MAX), function=data['can_led_4_function']))