class LoginTests(unittest.TestCase):

    valid_email = ""
    valid_password = ""

    @pytest.fixture(autouse=True)
    def classSetup(self, oneTimeSetUp):
        self.lp = LoginPage(self.driver)
        self.assertStatus = AssertStatus(self.driver)
        self.tool = Toolbox()

    @pytest.mark.run(order=1)
    def test_invalidLogin(self):
        email = self.tool.getuniqueemail()
        password = self.tool.getuniquepassword()

        self.lp.login(email, password)
        result = self.lp.verifyLoginFailed()
        assert result == True

    @pytest.mark.run(order=2)
    def test_validLogin(self):
        login = self.valid_email
        password = self.valid_password
        self.lp.login(login, password)
        result1 = self.lp.verifyLoginTitle()
        self.assertStatus.mark(result1, "Title Verification")
        result2 = self.lp.verifyLoginSuccessful()
        self.assertStatus.markFinal("test_validLogin", result2,
                                    "Login Verification")
示例#2
0
 def dto_to_orm(
         thermostat_group_dto,
         fields):  # type: (ThermostatGroupDTO, List[str]) -> EepromModel
     data = {}  # type: Dict[str, Any]
     for dto_field, orm_field in {
             'outside_sensor_id': 'outside_sensor',
             'threshold_temperature': 'threshold_temp',
             'pump_delay': 'pump_delay'
     }.items():
         if dto_field in fields:
             data[orm_field] = Toolbox.denonify(
                 getattr(thermostat_group_dto, dto_field),
                 ThermostatGroupMapper.BYTE_MAX)
     for mode in ['heating', 'cooling']:
         for i in range(4):
             output = 'switch_to_{0}_output_{1}'.format(mode, i)
             value = 'switch_to_{0}_value_{1}'.format(mode, i)
             field = 'switch_to_{0}_{1}'.format(mode, i)
             if field in fields:
                 dto_value = getattr(
                     thermostat_group_dto,
                     field)  # type: Optional[Tuple[int, int]]
                 data[output] = Toolbox.denonify(
                     None if dto_value is None else dto_value[0],
                     ThermostatGroupMapper.BYTE_MAX)
                 data[value] = Toolbox.denonify(
                     None if dto_value is None else dto_value[1],
                     ThermostatGroupMapper.BYTE_MAX)
     return GlobalThermostatConfiguration.deserialize(data)
示例#3
0
 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)
示例#4
0
 def serialize(
         thermostat_group_dto,
         fields):  # type: (ThermostatGroupDTO, Optional[List[str]]) -> Dict
     data = {
         'id':
         thermostat_group_dto.id,
         'outside_sensor':
         Toolbox.denonify(thermostat_group_dto.outside_sensor_id,
                          ThermostatGroupSerializer.BYTE_MAX),
         'threshold_temp':
         Toolbox.denonify(thermostat_group_dto.threshold_temperature,
                          ThermostatGroupSerializer.BYTE_MAX),
         'pump_delay':
         Toolbox.denonify(thermostat_group_dto.pump_delay,
                          ThermostatGroupSerializer.BYTE_MAX)
     }
     for mode in ['heating', 'cooling']:
         for i in range(4):
             output = 'switch_to_{0}_output_{1}'.format(mode, i)
             value = 'switch_to_{0}_value_{1}'.format(mode, i)
             field = 'switch_to_{0}_{1}'.format(mode, i)
             dto_value = getattr(thermostat_group_dto,
                                 field)  # type: Optional[Tuple[int, int]]
             data[output] = Toolbox.denonify(
                 None if dto_value is None else dto_value[0],
                 ThermostatGroupSerializer.BYTE_MAX)
             data[value] = Toolbox.denonify(
                 None if dto_value is None else dto_value[1],
                 ThermostatGroupSerializer.BYTE_MAX)
     return SerializerToolbox.filter_fields(data, fields)
示例#5
0
 def serialize(
         global_feedback_dto,
         fields):  # type: (GlobalFeedbackDTO, Optional[List[str]]) -> Dict
     data = {
         'id':
         global_feedback_dto.id,
         'can_led_1_id':
         Toolbox.denonify(global_feedback_dto.can_led_1.id,
                          GlobalFeedbackSerializer.BYTE_MAX),
         'can_led_1_function':
         global_feedback_dto.can_led_1.function,
         'can_led_2_id':
         Toolbox.denonify(global_feedback_dto.can_led_2.id,
                          GlobalFeedbackSerializer.BYTE_MAX),
         'can_led_2_function':
         global_feedback_dto.can_led_2.function,
         'can_led_3_id':
         Toolbox.denonify(global_feedback_dto.can_led_3.id,
                          GlobalFeedbackSerializer.BYTE_MAX),
         'can_led_3_function':
         global_feedback_dto.can_led_3.function,
         'can_led_4_id':
         Toolbox.denonify(global_feedback_dto.can_led_4.id,
                          GlobalFeedbackSerializer.BYTE_MAX),
         'can_led_4_function':
         global_feedback_dto.can_led_4.function
     }
     return SerializerToolbox.filter_fields(data, fields)
示例#6
0
 def dto_to_orm(model_type, pump_group_dto):  # type: (Type[EepromModel], PumpGroupDTO) -> EepromModel
     data = {'id': pump_group_dto.id}  # type: Dict[str, Any]
     if 'pump_output_id' in pump_group_dto.loaded_fields:
         data['output'] = Toolbox.denonify(pump_group_dto.pump_output_id, PumpGroupMapper.BYTE_MAX)
     if 'valve_output_ids' in pump_group_dto.loaded_fields:
         data['outputs'] = ','.join(str(output_id) for output_id in pump_group_dto.valve_output_ids)
     if 'room_id' in pump_group_dto.loaded_fields:
         data['room'] = Toolbox.denonify(pump_group_dto.room_id, PumpGroupMapper.BYTE_MAX)
     return model_type.deserialize(data)
示例#7
0
 def dto_to_orm(
         pulse_counter_dto):  # type: (PulseCounterDTO) -> EepromModel
     data = {'id': pulse_counter_dto.id}  # type: Dict[str, Any]
     if 'name' in pulse_counter_dto.loaded_fields:
         data['name'] = Toolbox.shorten_name(pulse_counter_dto.name)
     if 'input_id' in pulse_counter_dto.loaded_fields:
         data['input'] = Toolbox.denonify(pulse_counter_dto.input_id,
                                          PulseCounterMapper.BYTE_MAX)
     return PulseCounterConfiguration.deserialize(data)
示例#8
0
 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)
示例#9
0
 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
示例#10
0
 def serialize(sensor_dto,
               fields):  # type: (SensorDTO, Optional[List[str]]) -> Dict
     data = {
         'id': sensor_dto.id,
         'name': sensor_dto.name,
         'offset': Toolbox.denonify(sensor_dto.offset, 0),
         'room': Toolbox.denonify(sensor_dto.room,
                                  SensorSerializer.BYTE_MAX),
         'virtual': sensor_dto.virtual
     }
     return SerializerToolbox.filter_fields(data, fields)
示例#11
0
def main():
    """Start the program."""

    toolbox = Toolbox()
    toolbox.process_command_line_arguments()

    # This will also run the graphical interface
    return_code = toolbox.run()

    print(f"Main: exiting gracefully (return code={return_code}).")
    sys.exit(return_code)
示例#12
0
 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']))
示例#13
0
 def dto_to_orm(shutter_dto):  # type: (ShutterDTO) -> EepromModel
     data = {'id': shutter_dto.id,
             'name': shutter_dto.name}
     for field in ['name']:
         if field in shutter_dto.loaded_fields:
             data[field] = getattr(shutter_dto, field)
     for field in ['timer_up', 'timer_down', 'up_down_config', 'group_1', 'group_2']:
         if field in shutter_dto.loaded_fields:
             data[field] = Toolbox.denonify(getattr(shutter_dto, field), ShutterMapper.BYTE_MAX)
     for field in ['steps']:
         if field in shutter_dto.loaded_fields:
             data[field] = Toolbox.denonify(getattr(shutter_dto, field), ShutterMapper.WORD_MAX)
     return ShutterConfiguration.deserialize(data)
示例#14
0
 def serialize(
         thermostat_dto,
         fields):  # type: (ThermostatDTO, Optional[List[str]]) -> Dict
     data = {
         'id':
         thermostat_dto.id,
         'name':
         thermostat_dto.name,
         'room':
         Toolbox.denonify(thermostat_dto.room,
                          ThermostatSerializer.BYTE_MAX),
         'setp0':
         thermostat_dto.setp0,
         'setp1':
         thermostat_dto.setp1,
         'setp2':
         thermostat_dto.setp2,
         'setp3':
         thermostat_dto.setp3,
         'setp4':
         thermostat_dto.setp4,
         'setp5':
         thermostat_dto.setp5,
         'sensor':
         Toolbox.denonify(thermostat_dto.sensor,
                          ThermostatSerializer.BYTE_MAX),
         'output0':
         Toolbox.denonify(thermostat_dto.output0,
                          ThermostatSerializer.BYTE_MAX),
         'output1':
         Toolbox.denonify(thermostat_dto.output1,
                          ThermostatSerializer.BYTE_MAX),
         'pid_p':
         Toolbox.denonify(thermostat_dto.pid_p,
                          ThermostatSerializer.BYTE_MAX),
         'pid_i':
         Toolbox.denonify(thermostat_dto.pid_i,
                          ThermostatSerializer.BYTE_MAX),
         'pid_d':
         Toolbox.denonify(thermostat_dto.pid_d,
                          ThermostatSerializer.BYTE_MAX),
         'pid_int':
         Toolbox.denonify(thermostat_dto.pid_int,
                          ThermostatSerializer.BYTE_MAX),
         'permanent_manual':
         thermostat_dto.permanent_manual
     }
     for day in ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']:
         field = 'auto_{0}'.format(day)
         dto_data = getattr(thermostat_dto,
                            field)  # type: ThermostatScheduleDTO
         if dto_data is None:
             raise RuntimeError(
                 'Schedules are mandatory in the ThermostatSerializer')
         data[field] = [
             dto_data.temp_night, dto_data.start_day_1, dto_data.end_day_1,
             dto_data.temp_day_1, dto_data.start_day_2, dto_data.end_day_2,
             dto_data.temp_day_2
         ]
     return SerializerToolbox.filter_fields(data, fields)
示例#15
0
 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
示例#16
0
 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
示例#17
0
 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
示例#18
0
 def dto_to_orm(shutter_dto):  # type: (ShutterGroupDTO) -> EepromModel
     data = {'id': shutter_dto.id}
     for field in ['timer_up', 'timer_down']:
         if field in shutter_dto.loaded_fields:
             data[field] = Toolbox.denonify(getattr(shutter_dto, field),
                                            ShutterGroupMapper.BYTE_MAX)
     return ShutterGroupConfiguration.deserialize(data)
示例#19
0
 def dto_to_orm(
     model_type, thermostat_dto, fields
 ):  # type: (Type[EepromModel], ThermostatDTO, List[str]) -> EepromModel
     data = {'id': thermostat_dto.id}  # type: Dict[str, Any]
     for field in ['name', 'permanent_manual'
                   ] + ['setp{0}'.format(i) for i in range(6)]:
         if field in fields:
             data[field] = getattr(thermostat_dto, field)
     for field in [
             'sensor', 'output0', 'output1', 'pid_p', 'pid_i', 'pid_d',
             'pid_int', 'room'
     ]:
         if field in fields:
             data[field] = Toolbox.denonify(getattr(thermostat_dto, field),
                                            ThermostatMapper.BYTE_MAX)
     for day in ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']:
         field = 'auto_{0}'.format(day)
         if field not in fields:
             continue
         dto_data = getattr(thermostat_dto,
                            field)  # type: ThermostatScheduleDTO
         if dto_data is None:
             continue
         data[field] = [
             dto_data.temp_night, dto_data.start_day_1, dto_data.end_day_1,
             dto_data.temp_day_1, dto_data.start_day_2, dto_data.end_day_2,
             dto_data.temp_day_2
         ]
     return model_type.deserialize(data)
示例#20
0
 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)
示例#21
0
 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)
示例#22
0
 def _handle_request(self, method, args, kwargs):
     func = getattr(self._plugin, method)
     requested_parameters = set(
         Toolbox.get_parameter_names(func)) - {'self'}
     difference = set(kwargs.keys()) - requested_parameters
     if difference:
         # Analog error message as the default CherryPy behavior
         return {
             'success':
             False,
             'exception':
             'Unexpected query string parameters: {0}'.format(
                 ', '.join(difference))
         }
     difference = requested_parameters - set(kwargs.keys())
     if difference:
         # Analog error message as the default CherryPy behavior
         return {
             'success':
             False,
             'exception':
             'Missing parameters: {0}'.format(', '.join(difference))
         }
     try:
         return {'success': True, 'response': func(*args, **kwargs)}
     except Exception as exception:
         return {
             'success': False,
             'exception': str(exception),
             'stacktrace': traceback.format_exc()
         }
示例#23
0
 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)
示例#24
0
 def dto_to_orm(output_dto):  # type: (OutputDTO) -> EepromModel
     data = {'id': output_dto.id}
     for dto_field, data_field in {
             'module_type': 'module_type',
             'name': 'name',
             'output_type': 'type'
     }.items():
         if dto_field in output_dto.loaded_fields:
             data[data_field] = getattr(output_dto, dto_field)
     for dto_field, (data_field, default) in {
             'timer': ('timer', OutputMapper.WORD_MAX),
             'floor': ('floor', OutputMapper.BYTE_MAX),
             'lock_bit_id': ('lock_bit_id', OutputMapper.BYTE_MAX)
     }.items():
         if dto_field in output_dto.loaded_fields:
             data[data_field] = Toolbox.denonify(
                 getattr(output_dto, dto_field), default)
     for i in range(4):
         base_field = 'can_led_{0}'.format(i + 1)
         if base_field in output_dto.loaded_fields:
             id_field = '{0}_id'.format(base_field)
             function_field = '{0}_function'.format(base_field)
             data[id_field] = getattr(output_dto, base_field).id
             data[function_field] = getattr(output_dto, base_field).function
     return OutputConfiguration.deserialize(data)
示例#25
0
    def nexar_onboarding(self):

        os.system(st.reset_perm_script)  #RESET ALL NEXAR PERMISSIONS BY SCRIPT

        self.nexar_driver.start_session(
            tb.nexar_appium_desired_capadibilties())

        self.pass_nexar_permissions()

        self.enter_login_details()

        self.otp_extractor_from_notifications("into Nexar")

        self.nexar_driver.press_keycode(4)

        self.nexar_driver.background_app(0.1)

        try:
            self.enter_login_details()
        except Exception as err:
            self.wait.until(ec.element_to_be_clickable((By.ID, bt.RESEND_OTP)))

        self.nexar_driver.find_element_by_id(st.PIN_CODE_UI).send_keys(
            self.value)

        self.nexar_driver.find_element_by_id(bt.LOGIN_BUTTON).click()

        self.wait.until(ec.element_to_be_clickable((By.XPATH, bt.AGREE_TOS)))

        self.nexar_driver.find_element_by_xpath(bt.AGREE_TOS).click()
示例#26
0
 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)
示例#27
0
 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)
示例#28
0
 def serialize(
         shutter_group_dto,
         fields):  # type: (ShutterGroupDTO, Optional[List[str]]) -> Dict
     data = {
         'id':
         shutter_group_dto.id,
         'timer_up':
         Toolbox.denonify(shutter_group_dto.timer_up,
                          ShutterGroupSerializer.BYTE_MAX),
         'timer_down':
         Toolbox.denonify(shutter_group_dto.timer_down,
                          ShutterGroupSerializer.BYTE_MAX),
         'room':
         Toolbox.denonify(shutter_group_dto.room,
                          ShutterGroupSerializer.BYTE_MAX)
     }
     return SerializerToolbox.filter_fields(data, fields)
示例#29
0
文件: room.py 项目: rolaya/gateway
 def serialize(room_dto,
               fields):  # type: (RoomDTO, Optional[List[str]]) -> Dict
     data = {
         'id': room_dto.id,
         'name': Toolbox.denonify(room_dto.name, ''),
         'floor': 255 if room_dto.floor is None else room_dto.floor.id
     }
     return SerializerToolbox.filter_fields(data, fields)
示例#30
0
 def serialize(pump_group_dto,
               fields):  # type: (PumpGroupDTO, Optional[List[str]]) -> Dict
     data = {
         'id':
         pump_group_dto.id,
         'output':
         Toolbox.denonify(pump_group_dto.pump_output_id,
                          PumpGroupSerializer.BYTE_MAX),
         'outputs':
         ','.join(
             str(output_id)
             for output_id in pump_group_dto.valve_output_ids),
         'room':
         Toolbox.denonify(pump_group_dto.room_id,
                          PumpGroupSerializer.BYTE_MAX)
     }
     return SerializerToolbox.filter_fields(data, fields)
示例#31
0
 def new_function(*args, **kw):
     """
     Wrapped function
     """
     request = _find_request(args)
     if not hasattr(request, 'user') or not hasattr(request, 'client'):
         raise NotAuthenticated()
     user = UserList.get_user_by_username(request.user.username)
     if user is None:
         raise NotAuthenticated()
     if not Toolbox.is_token_in_roles(request.token, roles):
         raise PermissionDenied('This call requires roles: %s' % (', '.join(roles)))
     return f(*args, **kw)
示例#32
0
        def new_function(*args, **kwargs):
            """
            Wrapped function
            """
            request = _find_request(args)

            # 1. Pre-loading request data
            sort = request.QUERY_PARAMS.get('sort')
            if sort is None and default_sort is not None:
                sort = default_sort
            sort = None if sort is None else [s for s in reversed(sort.split(','))]
            page = request.QUERY_PARAMS.get('page')
            page = int(page) if page is not None and page.isdigit() else None
            page_size = request.QUERY_PARAMS.get('page_size')
            page_size = int(page_size) if page_size is not None and page_size.isdigit() else None
            page_size = page_size if page_size in [10, 25, 50, 100] else 10
            contents = request.QUERY_PARAMS.get('contents')
            contents = None if contents is None else contents.split(',')

            # 2. Construct hints for decorated function (so it can provide full objects if required)
            if 'hints' not in kwargs:
                kwargs['hints'] = {}
            kwargs['hints']['full'] = sort is not None or contents is not None

            # 3. Fetch data
            data_list = f(*args, **kwargs)
            guid_list = isinstance(data_list, list) and len(data_list) > 0 and isinstance(data_list[0], basestring)

            # 4. Sorting
            if sort is not None:
                if guid_list is True:
                    data_list = [object_type(guid) for guid in data_list]
                    guid_list = False  # The list is converted to objects
                for sort_item in sort:
                    desc = sort_item[0] == '-'
                    field = sort_item[1 if desc else 0:]
                    data_list.sort(key=lambda e: Toolbox.extract_key(e, field), reverse=desc)

            # 5. Paging
            total_items = len(data_list)
            page_metadata = {'total_items': total_items,
                             'current_page': 1,
                             'max_page': 1,
                             'page_size': page_size,
                             'start_number': min(1, total_items),
                             'end_number': total_items}
            if page is not None:
                max_page = int(math.ceil(total_items / (page_size * 1.0)))
                if page > max_page:
                    page = max_page
                if page == 0:
                    start_number = -1
                    end_number = 0
                else:
                    start_number = (page - 1) * page_size  # Index - e.g. 0 for page 1, 10 for page 2
                    end_number = start_number + page_size  # Index - e.g. 10 for page 1, 20 for page 2
                data_list = data_list[start_number: end_number]
                page_metadata = dict(page_metadata.items() + {'current_page': max(1, page),
                                                              'max_page': max(1, max_page),
                                                              'start_number': start_number + 1,
                                                              'end_number': min(total_items, end_number)}.items())

            # 6. Serializing
            if contents is not None:
                if guid_list is True:
                    data_list = [object_type(guid) for guid in data_list]
                data = FullSerializer(object_type, contents=contents, instance=data_list, many=True).data
            else:
                if guid_list is False:
                    data_list = [item.guid for item in data_list]
                data = data_list

            result = {'data': data,
                      '_paging': page_metadata,
                      '_contents': contents,
                      '_sorting': [s for s in reversed(sort)] if sort else sort}

            # 7. Building response
            return Response(result, status=status.HTTP_200_OK)