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']))
