Example #1
0
    async def _delete_ot(ot: str) -> None:

        obj_type = glob.OBJECT_TYPES[ot]

        if obj_type.meta.built_in:
            raise Arcor2Exception("Can't delete built-in type.")

        for obj in glob.OBJECT_TYPES.values():
            if obj.meta.base == ot:
                raise Arcor2Exception(
                    f"Object type is base of '{obj.meta.type}'.")

        async for scene in scenes():
            check_scene_for_object_type(scene, ot)

        if glob.LOCK.scene:
            check_scene_for_object_type(glob.LOCK.scene, ot)

        if req.dry_run:
            return

        await asyncio.gather(storage.delete_object_type(ot),
                             _delete_model(obj_type), remove_object_type(ot))

        await glob.LOCK.write_unlock(
            ot, user_name
        )  # need to be unlocked while it exists in glob.OBJECT_TYPES
        del glob.OBJECT_TYPES[ot]

        evt = sevts.o.ChangedObjectTypes([obj_type.meta])
        evt.change_type = events.Event.Type.REMOVE
        asyncio.create_task(notif.broadcast_event(evt))
Example #2
0
async def list_scenes_cb(req: srpc.s.ListScenes.Request,
                         ui: WsClient) -> srpc.s.ListScenes.Response:

    resp = srpc.s.ListScenes.Response()
    resp.data = []

    async for scene in scenes():
        resp.data.append(
            resp.Data(scene.id, scene.name, scene.desc, scene.modified))

    return resp
Example #3
0
async def object_type_usage_cb(
        req: srpc.o.ObjectTypeUsage.Request,
        ui: WsClient) -> srpc.o.ObjectTypeUsage.Response:

    resp = srpc.o.ObjectTypeUsage.Response()
    resp.data = set(
    )  # mypy does not recognize it correctly with Response(data=set())

    async for scene in scenes():
        if req.args.id in scene.object_types:
            resp.data.add(scene.id)

    return resp
Example #4
0
async def delete_object_type_cb(req: srpc.o.DeleteObjectType.Request,
                                ui: WsClient) -> None:

    async with glob.LOCK.get_lock(req.dry_run):

        try:
            obj_type = glob.OBJECT_TYPES[req.args.id]
        except KeyError:
            raise Arcor2Exception("Unknown object type.")

        if obj_type.meta.built_in:
            raise Arcor2Exception("Can't delete built-in type.")

        for obj in glob.OBJECT_TYPES.values():
            if obj.meta.base == req.args.id:
                raise Arcor2Exception(
                    f"Object type is base of '{obj.meta.type}'.")

        async for scene in scenes():
            check_scene_for_object_type(scene, req.args.id)

        if glob.LOCK.scene:
            check_scene_for_object_type(glob.LOCK.scene, req.args.id)

        if req.dry_run:
            return

        await storage.delete_object_type(req.args.id)

        # do not care so much if delete_model fails
        if obj_type.meta.object_model:
            try:
                await storage.delete_model(
                    obj_type.meta.object_model.model().id)
            except storage.ProjectServiceException as e:
                glob.logger.error(str(e))

        del glob.OBJECT_TYPES[req.args.id]
        await hlp.run_in_executor(remove_object_type, req.args.id)

        evt = sevts.o.ChangedObjectTypes([obj_type.meta])
        evt.change_type = events.Event.Type.REMOVE
        asyncio.ensure_future(notif.broadcast_event(evt))