async def patch_meter(request: Request, meter_id: int, body: ChangeMeterModel, db: Session = Depends(get_db),):
    has_permission(request, PermissionSet.MeterEdit.value)
    meter = db.query(Meter).filter_by(id=meter_id).first()

    change_dict = body.dict(exclude_unset=True)
    electricity_dict = change_dict.pop('electricity', None)
    args = {k: v for k, v in change_dict.items()}
    for k, v in args.items():
        setattr(meter, k, v)

    if meter.type == MeterType.Electricity:
        if electricity_dict:
            if meter.electricity:
                for k, v in electricity_dict.items():
                    setattr(meter.electricity, k, v)
            else:
                electricity = ElectricityMeter(**electricity_dict)
                meter.electricity = electricity
        elif not meter.electricity:
            raise HTTPException(detail='Electricity info is needed', status_code=400)

    elif meter.electricity:
        db.query(ElectricityMeter).filter_by(id=meter.electricity.id).delete()
        meter.electricity = None

    db.merge(meter)
    db.commit()
    return MeterModel.from_orm(meter)
Exemple #2
0
async def remove_room(request: Request,
                      room_id: int,
                      db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.RoomEdit.value)
    db.query(Room).filter_by(id=room_id).delete()
    db.commit()
    return ""
Exemple #3
0
async def remove_building_type(request: Request,
                               building_type_id: int,
                               db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.BuildingTypeEdit.value)
    db.query(BuildingType).filter_by(id=building_type_id).delete()
    db.commit()
    return ""
async def remove_location(request: Request,
                          location_id: int,
                          db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.LocationEdit.value)
    db.query(Location).filter_by(id=location_id).delete()
    db.commit()
    return ""
Exemple #5
0
async def get_floors(request: Request, db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.FloorRead.value)
    return paginate(
        db=db,
        db_model=Floor,
        serializer=FloorModel,
        request=request
    )
async def get_environmental_readings(request: Request, db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.RoomRead.value)
    return paginate(
        db=db,
        db_model=EnvironmentalReading,
        serializer=EnvironmentalReadingModel,
        request=request
    )
async def add_responsible_user(
        request: Request,
        body: AddResponsibleUserModel,
        db: Session = Depends(get_db),
):
    has_permission(request, PermissionSet.BuildingEdit.value)
    if not (user := get_user(body.user_id)):
        raise HTTPException(detail='User does not exist', status_code=400)
Exemple #8
0
async def get_meter_snapshots(request: Request, db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.MeterSnapshotRead.value)
    return paginate(
        db=db,
        db_model=MeterSnapshot,
        serializer=MeterSnapshotModel,
        request=request
    )
Exemple #9
0
async def add_floor(request: Request, body: AddFloorModel, db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.FloorEdit.value)
    floor = Floor(**body.dict())
    db.add(floor)
    try:
        db.commit()
    except IntegrityError:
        raise HTTPException(detail='Floor already exists', status_code=400)
    return FloorModel.from_orm(floor)
async def remove_responsible_user_by_user_id(
        request: Request,
        user_id: int,
        db: Session = Depends(get_db),
):
    has_permission(request, PermissionSet.BuildingEdit.value)
    db.query(ResponsibleUser).filter_by(user_id=user_id).delete()
    db.commit()
    return ""
Exemple #11
0
async def get_building_types(
        request: Request,
        db: Session = Depends(get_db),
):
    has_permission(request, PermissionSet.BuildingTypeRead.value)
    return paginate(db=db,
                    db_model=BuildingType,
                    serializer=BuildingTypeModel,
                    request=request)
async def add_environmental_reading(request: Request, body: AddEnvironmentalReadingModel,
                                    db: Session = Depends(get_db), ):
    has_permission(request, PermissionSet.RoomEdit.value)
    environmental_reading = EnvironmentalReading(**body.dict())
    db.add(environmental_reading)
    try:
        db.commit()
    except IntegrityError:
        raise HTTPException(detail='EnvironmentalReading already exists', status_code=400)
    return EnvironmentalReadingModel.from_orm(environmental_reading)
Exemple #13
0
async def get_buildings(request: Request, db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.BuildingRead.value)
    paginated = paginate(db=db,
                         db_model=Building,
                         serializer=BuildingModel,
                         request=request)
    for index, building in enumerate(paginated['items']):
        for user in building.responsible_people:
            user.user = get_user(user.user_id)
    return paginated
Exemple #14
0
async def add_room(request: Request,
                   body: AddRoomModel,
                   db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.RoomEdit.value)
    room = Room(**body.dict())
    db.add(room)
    try:
        db.commit()
    except IntegrityError:
        raise HTTPException(detail='Room already exists', status_code=400)
    return RoomModel.from_orm(room)
Exemple #15
0
async def add_building(request: Request,
                       body: AddBuildingModel,
                       db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.BuildingEdit.value)
    building = Building(**body.dict())
    db.add(building)
    try:
        db.commit()
    except IntegrityError:
        raise HTTPException(detail='Building already exists', status_code=400)
    return BuildingModel.from_orm(building)
async def patch_environmental_reading(request: Request, environmental_reading_id: int,
                                      body: ChangeEnvironmentalReadingModel, db: Session = Depends(get_db), ):
    has_permission(request, PermissionSet.RoomEdit.value)
    environmental_reading = db.query(EnvironmentalReading).filter_by(id=environmental_reading_id).first()

    args = {k: v for k, v in body.dict(exclude_unset=True).items()}
    if args:
        for k, v in args.items():
            setattr(environmental_reading, k, v)

        db.add(environmental_reading)
        db.commit()
    return EnvironmentalReadingModel.from_orm(environmental_reading)
async def add_location(request: Request,
                       body: AddLocationModel,
                       db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.LocationEdit.value)
    location = Location(name=body.name,
                        latitude=body.latitude,
                        longitude=body.longitude)
    db.add(location)
    try:
        db.commit()
    except IntegrityError:
        raise HTTPException(detail='Location already exists', status_code=400)
    return LocationModel.from_orm(location)
Exemple #18
0
async def patch_building_type(
        request: Request,
        building_type_id: int,
        body: AddBuildingTypeModel,
        db: Session = Depends(get_db),
):
    has_permission(request, PermissionSet.BuildingTypeEdit.value)
    building_type = db.query(BuildingType).filter_by(
        id=building_type_id).first()

    building_type.name = body.name
    db.add(building_type)
    db.commit()
    return BuildingTypeModel.from_orm(building_type)
Exemple #19
0
async def patch_floor(request: Request, floor_id: int, body: ChangeFloorModel, db: Session = Depends(get_db), ):
    has_permission(request, PermissionSet.FloorEdit.value)
    floor = db.query(Floor).filter_by(id=floor_id).first()
    if not floor:
        raise HTTPException(detail='Floor does not exist', status_code=404)

    args = {k: v for k, v in body.dict(exclude_unset=True).items()}
    if args:
        for k, v in args.items():
            setattr(floor, k, v)

        db.add(floor)
        db.commit()
    return FloorModel.from_orm(floor)
Exemple #20
0
async def patch_building(request: Request,
                         building_id: int,
                         body: ChangeBuildingModel,
                         db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.BuildingEdit.value)
    building = db.query(Building).filter_by(id=building_id).first()

    args = {k: v for k, v in body.dict(exclude_unset=True).items()}
    if args:
        for k, v in args.items():
            setattr(building, k, v)

        db.add(building)
        db.commit()
    return BuildingModel.from_orm(building)
async def patch_responsible_user(request: Request,
                                 responsible_user_id: int,
                                 body: ChangeResponsibleUserModel,
                                 db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.BuildingEdit.value)
    responsible_user = db.query(ResponsibleUser).filter_by(
        id=responsible_user_id).first()

    args = {k: v for k, v in body.dict(exclude_unset=True).items()}
    if args:
        for k, v in args.items():
            setattr(responsible_user, k, v)

        db.add(responsible_user)
        db.commit()
    return ResponsibleUserModel.from_orm(responsible_user)
Exemple #22
0
async def patch_room(
        request: Request,
        room_id: int,
        body: ChangeRoomModel,
        db: Session = Depends(get_db),
):
    has_permission(request, PermissionSet.RoomEdit.value)
    room = db.query(Room).filter_by(id=room_id).first()

    args = {k: v for k, v in body.dict(exclude_unset=True).items()}
    if args:
        for k, v in args.items():
            setattr(room, k, v)

        db.add(room)
        db.commit()
    return RoomModel.from_orm(room)
async def patch_location(
        request: Request,
        location_id: int,
        body: ChangeLocationModel,
        db: Session = Depends(get_db),
):
    has_permission(request, PermissionSet.LocationEdit.value)
    location = db.query(Location).filter_by(id=location_id).first()

    args = {k: v for k, v in body.dict(exclude_unset=True).items()}
    if args:
        for k, v in args.items():
            setattr(location, k, v)

        db.add(location)
        db.commit()
    return LocationModel.from_orm(location)
Exemple #24
0
async def get_building_types_count(request: Request,
                                   db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.BuildingTypeRead.value)
    result_models, count, page_number = apply_filtering(
        db, BuildingType, request)
    items = [
        BuildingTypeCountModel(id=b.id,
                               name=b.name,
                               buildings_count=len(b.buildings))
        for b in result_models
    ]
    return {
        'total_size': count,
        'page_number': page_number,
        'page_size': len(items),
        'items': items
    }
async def get_responsible_users(request: Request,
                                db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.BuildingRead.value)
    result_models, count, page_number = apply_filtering(
        db=db, db_model=ResponsibleUser, request=request)

    items = [{
        'id': user.id,
        'rank': user.rank,
        'building_id': user.building_id,
        'user': get_user(user.user_id)
    } for user in result_models]
    return {
        'total_size': count,
        'page_number': page_number,
        'page_size': len(items),
        'items': items
    }
Exemple #26
0
def dispatch(message, status):
    """

    :type message: ChatMessage
    :type status: String
    """
    if status == 'SENDING' or status == 'READ':
        return
    msg_time = message.Datetime
    if msg_time < get_minute_ago():
        return
    logger.log_message(message)
    for e in events:
        func = events[e]
        regex = event_regex[e]
        f = re.findall(regex, message.Body)
        if len(f) > 0:
            for found in f:
                handler = func_handlers[func]
                handler.add({
                    'data': message,
                    'type': 'event',
                    'extra': {
                        'found': found
                    }
                })
            return
    if not message.Body.startswith('!'):
        return
    # Get args and command from message
    words = message.Body.split()
    cmd = words[0]
    cmd = cmd[1:]
    args = words[1:]
    # Check for valid command
    if not cmd in commands:
        message.Chat.SendMessage("Command not found!")
        return

    if cmd in command_permissions:
        permission = command_permissions[cmd]
        if not permissions.has_permission(message.Sender.Handle, permission):
            message.Chat.SendMessage("No permission to execute this command")
            return

    # Log command
    #base = u'Received command \'%s\'' % cmd
    #if len(args) > 0:
    #    base += u' with arguments: %s' % ' '.join(args)
    #logger.log(base)
    # Execute command
    func = commands[cmd]
    handler = func_handlers[func]
    handler.add({'data': message, 'type': 'command'})
async def add_meter(request: Request, body: AddMeterModel, db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.MeterEdit.value)
    meter_dict = body.dict()
    electricity = None
    if body.type == MeterType.Electricity:
        electricity_dict = meter_dict.pop('electricity', None)
        if electricity_dict:
            electricity = ElectricityMeter(**electricity_dict)
        else:
            raise HTTPException(detail='Electricity info is needed', status_code=400)

    meter = Meter(**meter_dict)
    meter.electricity = electricity
    db.add(meter)
    try:
        db.commit()
    except IntegrityError:
        raise HTTPException(detail='Bad info', status_code=400)

    return MeterModel.from_orm(meter)
Exemple #28
0
async def patch_meter_snapshot(request: Request, meter_snapshot_id: int, body: ChangeMeterSnapshotModel,
                               db: Session = Depends(get_db), ):
    has_permission(request, PermissionSet.MeterSnapshotEdit.value)
    meter_snapshot = db.query(MeterSnapshot).filter_by(id=meter_snapshot_id).first()

    previous_type = meter_snapshot.type

    snapshot_dict = body.dict(exclude_unset=True)
    heat_dict = snapshot_dict.pop('heat', {})
    electricity_dict = snapshot_dict.pop('electricity', {})

    args = {k: v for k, v in snapshot_dict.items()}
    for k, v in args.items():
        setattr(meter_snapshot, k, v)

    if meter_snapshot.type != previous_type:
        if previous_type == MeterType.Electricity:
            instance_to_delete = meter_snapshot.electricity_meter_snapshot
        elif previous_type == MeterType.Heat:
            instance_to_delete = meter_snapshot.heat_meter_snapshot
        else:
            #  previous_type == MeterType.Water
            instance_to_delete = meter_snapshot.water_meter_snapshot
        db.delete(instance_to_delete)

    if meter_snapshot.type == MeterType.Electricity:
        if meter_snapshot.electricity_meter_snapshot:
            for k, v in electricity_dict.items():
                setattr(meter_snapshot.electricity_meter_snapshot, k, v)
        else:
            meter_snapshot.electricity_meter_snapshot = ElectricityMeterSnapshot(**electricity_dict)
    elif meter_snapshot.type == MeterType.Heat:
        if meter_snapshot.heat_meter_snapshot:
            for k, v in heat_dict.items():
                setattr(meter_snapshot.heat_meter_snapshot, k, v)
        else:
            meter_snapshot.heat_meter_snapshot = HeatMeterSnapshot(**heat_dict)

    db.merge(meter_snapshot)
    db.commit()
    return MeterSnapshotModel.from_orm(meter_snapshot)
Exemple #29
0
async def add_meter_snapshot(request: Request, body: AddMeterSnapshotModel, db: Session = Depends(get_db), ):
    has_permission(request, PermissionSet.MeterSnapshotEdit.value)
    snapshot_dict = body.dict()
    snapshot_dict['automatic'] = False
    heat_dict = snapshot_dict.pop('heat', {})
    electricity_dict = snapshot_dict.pop('electricity', {})

    meter_snapshot = MeterSnapshot(**snapshot_dict)

    if body.type == MeterType.Electricity:
        meter_snapshot.electricity_meter_snapshot = ElectricityMeterSnapshot(**electricity_dict)
    elif body.type == MeterType.Heat:
        meter_snapshot.heat_meter_snapshot = HeatMeterSnapshot(**heat_dict)

    db.add(meter_snapshot)

    try:
        db.commit()
    except IntegrityError:
        raise HTTPException(detail='Bad info', status_code=400)

    return MeterSnapshotModel.from_orm(meter_snapshot)
Exemple #30
0
def dispatch(message, status):
    """

    :type message: ChatMessage
    :type status: String
    """
    if status == 'SENDING' or status == 'READ':
        return
    msg_time = message.Datetime
    if msg_time < get_minute_ago():
        return
    logger.log_message(message)
    for e in events:
        func = events[e]
        regex = event_regex[e]
        f = re.findall(regex, message.Body)
        if len(f) > 0:
            for found in f:
                handler = func_handlers[func]
                handler.add({'data': message, 'type': 'event', 'extra': {'found': found}})
            return
    if not message.Body.startswith('!'):
        return
    # Get args and command from message
    words = message.Body.split()
    cmd = words[0]
    cmd = cmd[1:]
    args = words[1:]
    # Check for valid command
    if not cmd in commands:
        message.Chat.SendMessage("Command not found!")
        return

    if cmd in command_permissions:
        permission = command_permissions[cmd]
        if not permissions.has_permission(message.Sender.Handle, permission):
            message.Chat.SendMessage("No permission to execute this command")
            return

    # Log command
    #base = u'Received command \'%s\'' % cmd
    #if len(args) > 0:
    #    base += u' with arguments: %s' % ' '.join(args)
    #logger.log(base)
    # Execute command
    func = commands[cmd]
    handler = func_handlers[func]
    handler.add({'data': message, 'type': 'command'})
Exemple #31
0
 def test_ObjectBinding(self):
   # test that permissions can be bound to objects
   class TestObject(db.Model):
     name = db.StringProperty(required=True)
     def __str__(self):
       return "TestObject:"+self.name
   o1 = TestObject(name="John").put()
   o2 = TestObject(name="Paul").put()
   o3 = TestObject(name="George").put()
   o4 = TestObject(name="Ringo").put()
   p1 = permissions.create('read')
   p2 = permissions.create('write')
   permissions.bind(p1,o1,o2,o3,o4)
   permissions.bind(p2,o3,o4)
   self.assert_(permissions.has_permission(o1,p1),"should return true for permission")
   self.assert_(permissions.has_permission(o2,p1),"should return true for permission")
   self.assert_(permissions.has_permission(o3,p1),"should return true for permission")
   self.assert_(permissions.has_permission(o4,p1),"should return true for permission")
   self.assert_(permissions.has_permission(o1,p2) == False,"object 1 should not have this permission")
   self.assert_(permissions.has_permission(o2,p2) == False,"object 2 should not have this permission")
   self.assert_(permissions.has_permission(o3,p2),"should return true for permission")
   self.assert_(permissions.has_permission(o4,p2),"should return true for permission")
async def get_locations(request: Request, db: Session = Depends(get_db)):
    has_permission(request, PermissionSet.LocationRead.value)
    return paginate(db=db,
                    db_model=Location,
                    serializer=LocationModel,
                    request=request)