예제 #1
0
 def post(self, userId):
     data = json.loads(self.request.body.decode("utf-8"))
     sensor = Sensor(None, data['type'], 0, [])
     sensor.name = data['name']
     sensor.gis = (data['lat'], data['lng'])
     sensor_id = self.__sensors_repo.create(sensor)
     self.__users_repo.add_sensor_id(userId, str(sensor_id))
     self.set_status(201)
예제 #2
0
 def __update_zwave_sensor(self, sensor: Sensor):
     new_value = self.__zwave_device.get_sensor_value(sensor.id)
     self.__logger.info("New value for sensor with id {0} is {1}: ".format(
         sensor.id, new_value))
     if None is not new_value:
         sensor.value = round(new_value, 1)
         sensor.last_updated = calendar.timegm(datetime.now().timetuple())
         self.__sensors_repo.set_sensor(sensor)
         dispatcher.send(SensorUpdateEvent.NAME,
                         event=SensorUpdateEvent(sensor))
예제 #3
0
 def register(self, jrequest, jresponse):
     assert isinstance(jrequest, JsonRpcRequest)
     assert isinstance(jresponse, JsonRpcResponse)
     jresponse.setId()
     request = jrequest.request
     assert isinstance(request, Request)
     if len(request.params) < 3:
         raise InvalidParams(
             "method=register&x=y&z=w&moduleId=mid&sensorId=sid&sensorName=mysensor where x is product field, y is product string, z is serial field, is serial string"
         )
     assert request.params.items()[0][0] == "method"
     assert request.params.items()[0][1] == "register"
     (product_name_field, product_name_string) = request.params.items()[1]
     (serial_number_field, serial_number_string) = request.params.items()[2]
     assert isinstance(product_name_field, str)
     product_name_field = unicode(product_name_field)
     assert isinstance(product_name_field, unicode)
     assert isinstance(serial_number_field, str)
     serial_number_field = unicode(serial_number_field)
     assert isinstance(serial_number_string, unicode)
     try:
         product_name_data = Data.prepare(product_name_field,
                                          product_name_string)
         serial_number_data = Data.prepare(serial_number_field,
                                           serial_number_string)
         module_id_string = request.get("moduleId")
         assert len(module_id_string) > 0
         sensor_id_string = request.get("sensorId")
         assert len(sensor_id_string) > 0
         module_id_data = Data.prepare("moduleId", request.get("moduleId"))
         sensor_id_data = Data.prepare("sensorId", request.get("sensorId"))
         existing_sensor = Sensor.getByProductNameSerialNumberModuleIdSensorId(
             product_name_data, serial_number_data, module_id_data,
             sensor_id_data)
         raise EntityExists(
             "Equipment", {
                 product_name_field: product_name_string,
                 serial_number_field: serial_number_string,
                 "moduleId": module_id_string,
                 "sensorId": sensor_id_string
             })
     except EntityNotFound:
         pass
     odenki_user = OdenkiUser.loadFromSession()
     assert isinstance(odenki_user, OdenkiUser)
     sensor_name = request.get("sensorName")
     if len(sensor_name) == 0: sensor_name = unicode(sensor_name)
     sensor_name_data = Data.prepare("sensorName", sensor_name)
     sensor = Sensor.create(product_name_data, serial_number_data,
                            module_id_data, sensor_id_data,
                            sensor_name_data, odenki_user)
     jresponse.addResult(sensor)
 def put(self, id):
     self.set_status(200)
     sensor_data = json.loads(self.request.body.decode("utf-8"))
     self.__logging.info('Sensor data received: '.format(
         self.request.body.decode("utf-8")))
     sensor = Sensor(id, sensor_data['type'], sensor_data['value'], None)
     event = Event(Event.TYPE_SENSOR_RECEIVED, sensor)
     self.__async_jobs.publish(event)
 def callback(self, location: LocationEvent) -> None:
     current_coordonates = (location.get_latitude(),
                            location.get_longitude())
     distance_from_home = vincenty(self.__home_coordonates,
                                   current_coordonates).km
     phone_is_home = distance_from_home < self.HOME_RADIUS
     sensor = Sensor('phoneIsHome', Sensor.SensorType.PHONE_IS_HOME.value,
                     False, phone_is_home)
     self.__sensors_repo.set_sensor(sensor)
예제 #6
0
    def get_sensors(self) -> List[Sensor]:
        sensors_data = self.get(self.__REDIS_SENSORS_KEY)
        sensors = []
        for sensor_data in sensors_data:
            # todo remove this hack after all sensors are updated
            last_updated = sensor_data[
                'last_updated'] if 'last_updated' in sensor_data else 0
            sensor = Sensor(sensor_data['id'], sensor_data['type'],
                            sensor_data['location'], sensor_data['value'],
                            sensor_data['device_type'], last_updated)
            if 'properties' in sensor_data:
                sensor.properties = self.__get_sensor_properties(
                    sensor_data['properties'])
            else:
                sensor.properties = self.__get_sensor_properties({})
            sensors.append(sensor)

        return sensors
예제 #7
0
 def listen(self, event: LocationEvent) -> None:
     current_coordonates = (event.get_latitude(), event.get_longitude())
     distance_from_home = vincenty(self.__home_coordonates,
                                   current_coordonates).km
     phone_is_home = distance_from_home < self.HOME_RADIUS
     sensor = Sensor('phoneIsHome', Sensor.SensorType.PHONE_IS_HOME.value,
                     False, phone_is_home, Sensor.DeviceType.ACTION.value,
                     calendar.timegm(datetime.now().timetuple()))
     self.__sensors_repo.set_sensor(sensor)
예제 #8
0
 def __get_sensor(self, sensor_components: list) -> Sensor:
     code, location, value = sensor_components
     if code not in self.SENSOR_TYPE_MAPPING:
         raise RuntimeError(
             'Code with {0} not mapped with any sensor'.format(code))
     if code == self.SENSOR_TYPE_SKIP:
         return None
     try:
         return Sensor(self.SENSOR_TYPE_MAPPING[code], float(value))
     except ValueError as e:
         raise RuntimeError(
             'Badly formatted sensor value: {0}, error: {1})'.format(
                 value, e.message))
예제 #9
0
 def register(self, jrequest, jresponse):
     assert isinstance(jrequest, JsonRpcRequest)
     assert isinstance(jresponse, JsonRpcResponse)
     jresponse.setId()
     request = jrequest.request
     assert isinstance(request, Request)
     if len(request.params) < 3:
         raise InvalidParams("method=register&x=y&z=w&moduleId=mid&sensorId=sid&sensorName=mysensor where x is product field, y is product string, z is serial field, is serial string")
     assert request.params.items()[0][0] == "method"
     assert request.params.items()[0][1] == "register"
     (product_name_field, product_name_string) = request.params.items()[1]
     (serial_number_field, serial_number_string) = request.params.items()[2]
     assert isinstance(product_name_field, str)
     product_name_field = unicode(product_name_field) 
     assert isinstance(product_name_field, unicode)
     assert isinstance(serial_number_field, str)
     serial_number_field = unicode(serial_number_field)
     assert isinstance(serial_number_string, unicode)
     try:
         product_name_data = Data.prepare(product_name_field, product_name_string)
         serial_number_data = Data.prepare(serial_number_field, serial_number_string)
         module_id_string = request.get("moduleId")
         assert len(module_id_string) > 0
         sensor_id_string = request.get("sensorId")
         assert len(sensor_id_string) > 0
         module_id_data = Data.prepare("moduleId", request.get("moduleId"))
         sensor_id_data = Data.prepare("sensorId", request.get("sensorId"))
         existing_sensor = Sensor.getByProductNameSerialNumberModuleIdSensorId(product_name_data, serial_number_data, module_id_data, sensor_id_data)
         raise EntityExists("Equipment", {product_name_field:product_name_string, serial_number_field: serial_number_string, "moduleId":module_id_string, "sensorId":sensor_id_string})
     except EntityNotFound: pass
     odenki_user = OdenkiUser.loadFromSession()
     assert isinstance(odenki_user, OdenkiUser)
     sensor_name = request.get("sensorName")
     if len(sensor_name) == 0: sensor_name = unicode(sensor_name)
     sensor_name_data = Data.prepare("sensorName", sensor_name)
     sensor = Sensor.create(product_name_data, serial_number_data, module_id_data, sensor_id_data, sensor_name_data, odenki_user)
     jresponse.addResult(sensor)
예제 #10
0
    def get_sensors(self) -> List[Sensor]:
        sensors_data = self.get(self.__REDIS_SENSORS_KEY)
        sensors = []
        for sensor_data in sensors_data:
            sensor = Sensor(sensor_data['id'], sensor_data['type'],
                            sensor_data['location'], sensor_data['value'])
            if 'name' in sensor_data:
                sensor.name = sensor_data['name']
            if 'communication_code' in sensor_data:
                sensor.communication_code = sensor_data['communication_code']
            else:
                sensor.communication_code = (False, False)
            if 'last_updated' in sensor_data:
                sensor.last_updated = sensor_data['last_updated']
            else:
                sensor.last_updated = 0
            sensors.append(sensor)

        return sensors
예제 #11
0
 def __process_sensor(self, sensor: Sensor, value):
     sensor.value = round(value, 3)
     sensor.last_updated = calendar.timegm(datetime.now().timetuple())
     self.__sensors_repository.set_sensor(sensor)
     dispatcher.send(SensorUpdateEvent.NAME,
                     event=SensorUpdateEvent(sensor))
예제 #12
0
                      "--days-behind",
                      required=True,
                      dest="days_behind",
                      type=int,
                      help="Days behind")
args = vars(argparse.parse_args())

container = Container()
datapoint_repository = container.datapoints_repository()
start_date = datetime.today() - timedelta(days=args['days_behind'])

for day_behind in range(args['days_behind'], 0, -1):
    start_date = datetime.today() - timedelta(days=day_behind)
    print('Calculating for date: ' + start_date.strftime('%m-%d-%Y'))
    request_url = config.darksky_url.format(int(start_date.timestamp()))
    response = requests.get(request_url)
    try:
        sensors_data = response.json()['hourly']['data']
    except Exception:
        print("Error transforming to json")
        continue
    for sensor_data in sensors_data:
        for darksky_sensor_name, sensor_name in config.darksky_sensor_mapping.items(
        ):
            if darksky_sensor_name not in sensor_data:
                continue
            date = datetime.fromtimestamp(sensor_data['time'])
            sensor = Sensor(sensor_name,
                            float(sensor_data[darksky_sensor_name]))
            datapoint_repository.update(DataSource.DARKSKY.value, date,
                                        [sensor])
 def __process_sensor(self, sensor: Sensor, value):
     sensor.value = round(value, 3)
     self.__sensors_repository.set_sensor(sensor)
     self.__sensor_update_event.send(sensor)
예제 #14
0
import requests

import config
from model.Sensor import Sensor
from container import Container
from model.DataSource import DataSource


argparse = argparse.ArgumentParser()
argparse.add_argument("-d", "--days-behind", required=True, dest="days_behind", type=int, help="Days behind")
args = vars(argparse.parse_args())

container = Container()
datapoint_repository = container.datapoints_repository()
start_date = datetime.today() - timedelta(days=args['days_behind'])

for day_behind in range(args['days_behind'], 0, -1):
    start_date = datetime.today() - timedelta(days=day_behind)
    print('Calculating for date: ' + start_date.strftime('%m-%d-%Y'))

    for home_automation_sensor_name, sensor_name in config.home_automation_sensor_mapping.items():
        literal_date = start_date.strftime('%m-%d-%Y')
        request = config.url.format(home_automation_sensor_name, literal_date, literal_date)
        response = requests.get(request)
        sensors_data = response.json()['data']
        if not len(sensors_data) or len(sensors_data) < 130:
            continue
        for sensor_data in sensors_data:
            date = datetime.fromtimestamp(sensor_data['timestamp'])
            sensor = Sensor(sensor_name, float(sensor_data['value']))
            datapoint_repository.update(DataSource.WEATHER_STATION.value, date, [sensor])