Merge branch 'AL-9273-new-block-cells' into 'master'

AL-9273 New block cells

See merge request avvy/blocks-admin!57

controllers/block.py

@@ -29,6 +29,7 @@ MANIFEST_TEMP = {
             ],
             "transformation": [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
             "hp": 100,
+            "manually_set_block_cells": False
         },
         "rules": [
             {
@@ -89,17 +90,29 @@ class Block(controller.Controller):
 
         is_new = False
         data = {}
+        has_ucs_process = False
         if bclass == "new":
             data = MANIFEST_TEMP
             data["_id"] = randrange(0, 1<<63)
             data["manifest"]["meta"]["id"] = str(data["_id"])
             is_new = True
+            ucs_process_status = None
         else:
             data = db_query.get_block(bclass)
             categories_list_view.select_by_value(data["manifest"]["meta"]["category"])
+            ucs_process_status = SERVICES.ucs_http_client.check_process_status(bclass)
+            if ucs_process_status is not None:
+                has_ucs_process = True
 
         data_models = {'categories_dropdown': categories_list_view}
-        self.render("block.html", data=data, json=json, is_new=is_new, data_models=data_models)
+
+        self.render("block.html",
+                    data=data,
+                    json=json,
+                    is_new=is_new,
+                    data_models=data_models,
+                    has_ucs_process=has_ucs_process,
+                    ucs_process_status=ucs_process_status)
 
     def post(self, bclass):
         data = {}
@@ -167,17 +180,20 @@ class Block(controller.Controller):
                     hex_dig = hash_object.hexdigest()
                     effect["hash"] = hex_dig
 
-        
-        db_query.add_block(data)
+        # Mutates data, split tags
+        updated_data = db_query.add_block(data)
+        updated_data["manifest"]["meta"]["tags"] = updated_data["manifest"]["meta"]["tags"].split(",")
 
         r = requests.post(
             url,
             data={'path': self.args["_id"], 'nohash': 1, 'force': 1},
             files={
-                "file": (self.args["_id"] + ".manifest", json.dumps(data["manifest"]))
+                "file": (self.args["_id"] + ".manifest", json.dumps(updated_data["manifest"]))
             })
 
-        SERVICES.ucs_http_client.schedule_ucs_manifest_import(data["_id"])
+        # Skip ucs if no glb supplied
+        if len(updated_data["manifest"]["meta"]["views"]) > 0:
+            SERVICES.ucs_http_client.schedule_ucs_manifest_import(updated_data["_id"])
 
         self.redirect("/block/" + self.args["_id"])
 

controllers/compute_cells.py

@@ -2,8 +2,7 @@ from base import controller
 from models.dbQuery import db_query
 import requests, json
 
-from controllers.view import compute_cels
-
+from services.depts import SERVICES
 from settings import ENV_VARS
 
 
@@ -11,22 +10,26 @@ class ComputeCells(controller.Controller):
 
     def post(self, bclass):
 
-        print(bclass)
-
         data = db_query.get_block(bclass)
         path = data["manifest"]["meta"]["views"]["0"]
-        cells = compute_cels(path)
 
-        data["manifest"]["properties"]["children"] = cells
+        # Set flag that block cells should be recalculated by algorithm
+        data["manifest"]["properties"]["manually_set_block_cells"] = False
 
-        db_query.add_block(data)
+        # Mutates data dictionary, splits tags
+        updated_data = db_query.add_block(data)
+        updated_data["manifest"]["meta"]["tags"] = updated_data["manifest"]["meta"]["tags"].split(",")
 
+        # Update db / storage with this flag
         r = requests.post(
             ENV_VARS.UPLOAD_PATH,
             data={'path': bclass, 'nohash': 1, 'force': 1},
             files={
-                "file": (bclass + ".manifest", json.dumps(data["manifest"]))
+                "file": (bclass + ".manifest", json.dumps(updated_data["manifest"]))
             })
 
-        self.write(json.dumps({'data': cells}))
+        # Schedule reimporting whole model to recalculate block cells
+        SERVICES.ucs_http_client.schedule_ucs_manifest_import(bclass)
+
+        # self.write(json.dumps({'data': cells}))
 

controllers/user_block_new.py

@@ -7,10 +7,11 @@ import trimesh
 import copy
 import numpy as np
 
+from services.depts import SERVICES
 from settings import ENV_VARS
 
 from controllers.block import MANIFEST_TEMP
-from controllers.view import compute_cels
+#from controllers.view import compute_cels
 
 from ui_model.models import ListDataModel
 
@@ -51,8 +52,8 @@ class UserBlockNew(controller.Controller):
         cat_ident = self.args.pop("category")
         selected_category = db_query.get_category_by_ident(cat_ident)
 
-        children = compute_cels(obj_path)
-        data["manifest"]["properties"]["children"] = children
+        #children = compute_cels(obj_path)
+        data["manifest"]["properties"]["children"] = []
         data["manifest"]["meta"]["views"]["0"] = obj_path
         data["manifest"]["meta"]["name"] = self.args.pop("name")
         data["manifest"]["meta"]["description"] = self.args.pop("desc")
@@ -61,6 +62,8 @@ class UserBlockNew(controller.Controller):
         data["manifest"]["meta"]["category_name"] = selected_category['name']
 
         # data["draft"] = True
-        db_query.add_block(data)
+        data = db_query.add_block(data)
+
+        SERVICES.ucs_http_client.schedule_ucs_manifest_import(data["_id"])
 
         self.write(json.dumps({'data': data}))

controllers/user_block_new_view.py

@@ -30,15 +30,15 @@ class UserBlockNewView(controller.Controller):
         print(obj_path)
 
         data["manifest"]["meta"]["views"][self.args["id"]] = obj_path
-        db_query.add_block(data)
+        updated_data = db_query.add_block(data)
 
-        self.write(json.dumps({'data': data}))
+        self.write(json.dumps({'data': updated_data}))
 
     def delete(self, bclass, view_id):
 
         data = db_query.get_block(bclass)
         del data["manifest"]["meta"]["views"][view_id]
-        db_query.add_block(data)
+        data = db_query.add_block(data)
 
         self.write(json.dumps({'data': data}))
 

controllers/view.py

@@ -3,129 +3,124 @@ from utils import init_log
 
 log = init_log(only_stream=True)
 
-import tornado
-from tornado.escape import json_encode
 import requests, json
-from random import randrange
 
 from base import controller
 from models.dbQuery import db_query
 
-import trimesh
-import numpy as np
-
 from settings import ENV_VARS
 
-def as_mesh(scene_or_mesh):
-    if isinstance(scene_or_mesh, trimesh.Scene):
-        mesh = trimesh.util.concatenate([
-            trimesh.Trimesh(vertices=m.vertices, faces=m.faces)
-            for m in scene_or_mesh.geometry.values()])
-    else:
-        mesh = scene_or_mesh
-    return mesh
-
-def compute_cels(path):
-    scene = trimesh.exchange.load.load_remote(path)
-    mesh = as_mesh(scene)
-    # geometries = list(mesh.geometry.values())
-
-    proximy = trimesh.proximity.ProximityQuery(mesh)
-
-    voxelized_mesh = mesh.voxelized(pitch=0.1).fill(method='holes')
-    small_mesh = True if len(voxelized_mesh.points) <= 9 else False
-
-    transform = np.array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
-
-    points_distance = proximy.signed_distance(voxelized_mesh.points)
-
-    def create_cell(point=[0,0,0]):
-        cell = {}
-        cell["object_type"] = 3
-        cell["props"] = {}
-        cell_transform = transform.copy()
-        cell_transform[12] = round(point[0] * 10)
-        cell_transform[13] = round(point[1] * 10)
-        cell_transform[14] = round(point[2] * 10)
-        cell["props"]["transformation"] = cell_transform.tolist()
-        return cell
-
-    cells = []
-    for p in range(len(voxelized_mesh.points)):
-        if points_distance[p] > -0.03 or small_mesh:
-            point = voxelized_mesh.points[p]
-            cell = create_cell(point)
-            cells.append(cell)
-    
-    if not len(cells):
-        cells.append(create_cell())
-
-    return cells
-
-
-def compute_and_post_storage(bclass, file, id):
-    log.info(f'bclass = {bclass} id = {id}')
-
-    data = db_query.get_block(bclass)
-
-    children = []
-    obj_path = ''
-
-    files_data = {"file": (file["filename"], file["body"], file["content_type"])}
-
-    r = requests.post(ENV_VARS.UPLOAD_PATH, data={'path': "avvy_assets"}, files=files_data)
-
-    if r.status_code == 404:
-        log.error(f'Got 404 from post file at {ENV_VARS.UPLOAD_PATH}')
-
-    filename = r.json()["files"]["file"]
-    obj_path = ENV_VARS.STORAGE_DIR_URL + '/' + filename
-
-    log.info(f'computing {obj_path}')
-
-    if int(id) == 0:
-        children = compute_cels(obj_path)
-        data["manifest"]["properties"]["children"] = children
-
-    if not data["manifest"]["meta"].get("views", False):
-        data["manifest"]["meta"]["views"] = {}
-
-    data["manifest"]["meta"]["views"][id] = obj_path
-
-    db_query.add_block(data)
-
-    r = requests.post(
-        ENV_VARS.UPLOAD_PATH,
-        data={'path': bclass, 'nohash': 1, 'force': 1},
-        files={
-            "file": (bclass + ".manifest", json.dumps(data["manifest"]))
-        })
-
-    return data
-
 
 class View(controller.Controller):
-    # @tornado.web.authenticated
 
     def post(self, bclass):
         # save assets
         file = self.request.files["asset"][0]
         id = self.args["id"]
 
-        data = compute_and_post_storage(bclass, file, id)
+        # Upload data to storage and into db
+        data = self._post_glb_and_manifest_to_storage(bclass, file, id)
 
-        self.write(json.dumps({'data': data}))
-
-        # Shall download manifest from storage and execute convertation routine
+        # Shall download manifest from storage and execute UCS routine, may update block cells directly into
+        # this database (in case they are not set to manual).
         SERVICES.ucs_http_client.schedule_ucs_manifest_import(data["_id"])
 
-        # self.redirect("/block/" + bclass)
-
-    # @tornado.web.authenticated
+        # return data back to refresh page
+        self.write(json.dumps({'data': data}))
 
     def delete(self, bclass, view_id):
         data = db_query.get_block(bclass)
         del data["manifest"]["meta"]["views"][view_id]
-        db_query.add_block(data)
+        data = db_query.add_block(data)
         self.write(json.dumps({'data': data}))
         # self.write_json({"status": True, "redirect": "/block/" + bclass})
+
+    def _post_glb_and_manifest_to_storage(self, bclass, file, id):
+        log.info(f'bclass = {bclass} id = {id}')
+
+        data = db_query.get_block(bclass)
+
+        files_data = {"file": (file["filename"], file["body"], file["content_type"])}
+
+        r = requests.post(ENV_VARS.UPLOAD_PATH, data={'path': "avvy_assets"}, files=files_data)
+
+        if r.status_code == 404:
+            log.error(f'Got 404 from post file at {ENV_VARS.UPLOAD_PATH}')
+
+        filename = r.json()["files"]["file"]
+        obj_path = ENV_VARS.STORAGE_DIR_URL + '/' + filename
+
+        log.info(f'computing {obj_path}')
+
+        if int(id) == 0:
+            # This shall be filled with UCS logic directly to the database and storage
+            data["manifest"]["properties"]["children"] = []
+            data["manifest"]["properties"]["manually_set_block_cells"] = False
+
+        if not data["manifest"]["meta"].get("views", False):
+            data["manifest"]["meta"]["views"] = {}
+
+        data["manifest"]["meta"]["views"][id] = obj_path
+
+        # Mutates data, splits tags
+        updated_data = db_query.add_block(data)
+        updated_data["manifest"]["meta"]["tags"] = updated_data["manifest"]["meta"]["tags"].split(",")
+
+        r = requests.post(
+            ENV_VARS.UPLOAD_PATH,
+            data={'path': bclass, 'nohash': 1, 'force': 1},
+            files={
+                "file": (bclass + ".manifest", json.dumps(updated_data["manifest"]))
+            })
+
+        return updated_data
+
+
+
+# def as_mesh(scene_or_mesh):
+#     if isinstance(scene_or_mesh, trimesh.Scene):
+#         mesh = trimesh.util.concatenate([
+#             trimesh.Trimesh(vertices=m.vertices, faces=m.faces)
+#             for m in scene_or_mesh.geometry.values()])
+#     else:
+#         mesh = scene_or_mesh
+#     return mesh
+#
+# def compute_cels(path):
+#     scene = trimesh.exchange.load.load_remote(path)
+#     mesh = as_mesh(scene)
+#     # geometries = list(mesh.geometry.values())
+#
+#     proximy = trimesh.proximity.ProximityQuery(mesh)
+#
+#     voxelized_mesh = mesh.voxelized(pitch=0.1).fill(method='holes')
+#     small_mesh = True if len(voxelized_mesh.points) <= 9 else False
+#
+#     transform = np.array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
+#
+#     points_distance = proximy.signed_distance(voxelized_mesh.points)
+#
+#     def create_cell(point=[0,0,0]):
+#         cell = {}
+#         cell["object_type"] = 3
+#         cell["props"] = {}
+#         cell_transform = transform.copy()
+#         cell_transform[12] = round(point[0] * 10)
+#         cell_transform[13] = round(point[1] * 10)
+#         cell_transform[14] = round(point[2] * 10)
+#         cell["props"]["transformation"] = cell_transform.tolist()
+#         return cell
+#
+#     cells = []
+#     for p in range(len(voxelized_mesh.points)):
+#         if points_distance[p] > -0.03 or small_mesh:
+#             point = voxelized_mesh.points[p]
+#             cell = create_cell(point)
+#             cells.append(cell)
+#
+#     if not len(cells):
+#         cells.append(create_cell())
+#
+#     return cells
+#
+#

local.ini

 # When deployed, generated with ansible/roles/server_tornado/templates/config.ini.tpl
 
 [ucs]
+# prod
+# ucs_http_address = http://68.183.66.117:8710
+# test
 ucs_http_address = http://165.227.139.116:8710
+# local
 # ucs_http_address = http://localhost:8888
+# local vagrant
+# ucs_http_address = http://localhost:8710
 
 [deploy]
 # Run migrations

migrations/004_block_cells_to_gridfs.py

+import json
+
+from bson import ObjectId
+
+from models.dbQuery import db_query
+
+from utils import init_log
+log = init_log(only_stream=True)
+
+'''
+Move block cells into grid fs collections
+'''
+
+migration_guid = 'e007b8af-4a9e-498d-8d83-d7a2a25c51bf'
+migration_order = 4
+changes_datamodel = True
+
+
+def run_migration():
+    for block_doc_i in db_query.mongo.blocks.find({}):
+        block_class_id = block_doc_i['_id']
+        # Check if it's already migrated
+        old_format = isinstance(block_doc_i['manifest']['properties']['children'], list)
+        if not old_format:
+            log.info(f'Skipping {block_class_id} - already migrated')
+            continue
+
+        # Create a file with block cells
+        block_cells_bin_json = json.dumps(block_doc_i['manifest']['properties']['children']).encode('utf-8')
+        block_cells_id = db_query.mongo_fs.put(block_cells_bin_json,
+                                               filename=f'{block_class_id}_cells.json',
+                                               bclass=f'{block_class_id}')
+        # Write manifest without block cells
+        block_doc_i['manifest']['properties']['children'] = {'gridfs_file_id': ObjectId(block_cells_id)}
+        db_query.mongo.blocks.update_one({'_id': block_class_id},
+                                         {'$set': block_doc_i},
+                                          upsert=True)
+
+        log.info(f'Migrating block cells for {block_class_id}')
+
+    return True
+
+
+if __name__ == '__main__':
+    # local debug call
+    run_migration()

migrations/005_ucs_process_uuid_idx.py

+from models.dbQuery import db_query
+
+from utils import init_log
+log = init_log(only_stream=True)
+
+
+migration_guid = 'bae30177-188f-40b2-abfa-53958a1d3a4e'
+migration_order = 5
+changes_datamodel = True
+
+
+def run_migration():
+    ucs_processes_col = db_query.mongo['ucs_processes']
+
+    log.info(f'Going to add index on ucs_processes')
+
+    ucs_processes_col.create_index([('bclass', 1)],
+                                   name='unique_bclass',
+                                   unique=True)
+
+    return True
+
+
+if __name__ == '__main__':
+    # local debug call
+    run_migration()

models/dbQuery.py

+import json
+
 import pymongo
 from pymongo import MongoClient
 from bson import ObjectId
-import uuid
-# import redis
-import json
-from datetime import datetime
-from tornado import escape
+import gridfs
 
 from settings import ENV_VARS
 
 client = MongoClient(ENV_VARS.MONGO_CONN)
 
 class DBQuery:
+    '''
+    Store manifest in mongo to simplify access (duplicated in storage).
+    block cells for some models are way too large (larger than 16Mb), so
+    we have to split cells in a separate gridfs collection.
+    '''
 
     # redis = redis.Redis()
     mongo = client[ENV_VARS.MONGO_DB]
+    mongo_fs = gridfs.GridFS(mongo)
 
-    # def set_secret(self, secret):
-    #     if self.redis.get('AvvyAuthSecret'):
-    #         return
-    #     self.redis.set('AvvyAuthSecret', secret)
-
-    # def get_secret(self):
-    #     return self.redis.get('AvvyAuthSecret').decode()
-
-    # def get_admins(self):
-    #     pass
-
-        # db_users = self.redis.keys("AvvyAdmin:*")
+    def add_block(self, data):
+        # A strange legacy line
+        data["manifest"]["meta"]["tags"] = data["manifest"]["meta"]["tags"].split(",")
 
-        # users = {}
+        # Store manifest in blocks collection, block cells go into grid fs
+        block_class_id = data['_id']
 
-        # for key in db_users:
-        #     key = key.decode()
-        #     user = key.split(":")
-        #     access = self.redis.get(key)
+        # Write new block_cells
+        block_cells_bin_json = json.dumps(data['manifest']['properties']['children']).encode('utf-8')
+        block_cells_file_id = self.mongo_fs.put(block_cells_bin_json,
+                                                filename=f'{block_class_id}_cells.json',
+                                                bclass=f'{block_class_id}')
+        data['manifest']['properties']['children'] = {'gridfs_file_id': ObjectId(block_cells_file_id)}
+        self.mongo.blocks.update_one({'_id': block_class_id},
+                                     {'$set': data},
+                                     upsert=True)
 
-        #     users[user[1]] = {"passw": user[2], "secret": str(
-        #         uuid.uuid4()), "access": int(access)}
+        # Delete old file for this block class
+        for file_i in self.mongo['fs.files'].find({'bclass': block_class_id}):
+            if file_i['_id'] != ObjectId(block_cells_file_id):
+                self.mongo_fs.delete(file_i['_id'])
 
-        # return users
+        # Now read data from database to ensure view format consistency (block cells are read from gridfs
+        data = self.get_block(bclass=block_class_id)
 
-    def add_block(self, data):
-        data["manifest"]["meta"]["tags"] = data["manifest"]["meta"]["tags"].split(",")
-        # self.mongo.blocks.save(data)  # save is already obsolete
-        self.mongo.blocks.update_one({'_id': data['_id']},
-                                     {'$set': data},
-                                     upsert=True)
         return data
 
     def get_blocks(self):
+        # No cells here
         data = self.mongo.blocks.find({})
         return data
 
-    def get_block(self, bclass = "new"):
+    def get_block(self, bclass="new"):
         data = self.mongo.blocks.find_one({"_id": bclass})
         if data:
             data["manifest"]["meta"]["tags"] = ",".join(data["manifest"]["meta"]["tags"]).replace(' ', '')
+        # Read block cells
+        gridfs_file_id = data['manifest']['properties']['children'].get('gridfs_file_id', None)
+        if gridfs_file_id:
+            res = self.mongo_fs.find_one({'_id': gridfs_file_id})
+            cells_json_file_data = b''
+            if res:
+                with res:
+                    for chunk_i in res:
+                        cells_json_file_data += chunk_i
+            data['manifest']['properties']['children'] = json.loads(cells_json_file_data.decode('utf-8'))
+        else:
+            data['manifest']['properties']['children'] = []
+
         return data
 
     def delete_block(self, bclass):
         self.mongo.blocks.delete_one({"_id": bclass})
+        for file_i in self.mongo['fs.files'].find({'bclass': bclass}):
+            self.mongo_fs.delete(file_i['_id'])
 
     def get_all_active_categories(self):
         data = self.mongo.categories.find({}).sort('order', pymongo.ASCENDING)
@@ -70,4 +84,14 @@ class DBQuery:
         data = self.mongo.categories.find_one({'ident': ident})
         return data
 
+    def register_ucs_process(self, bclass, process_uuid):
+        self.mongo.ucs_processes.update_one({'bclass': bclass},
+                                            {'$set': {'process_uuid': process_uuid}},
+                                            upsert=True)
+
+    def get_ucs_process_uuid_by_class_id(self, bclass):
+        data = self.mongo.ucs_processes.find_one({'bclass': bclass})
+        return data
+
+
 db_query = DBQuery()

server.py

@@ -38,7 +38,7 @@ if __name__ == '__main__':
     log = init_log(only_stream=True)
 
     kwargs = dict(arg.split('=') for arg in sys.argv[1:])
-    configfile_path = kwargs.get('config', DEFAULT_CONFIG)
+    configfile_path = kwargs.get('config')
     port_arg = kwargs.get('port', '8888')
     debug_arg = bool(int(kwargs.get('debug', '0')))
 

services/ucs_service/ucs_client.py

@@ -2,6 +2,7 @@ import logging
 
 import requests
 
+from models.dbQuery import db_query
 
 log = logging.getLogger('avvyland.web-app-backend-server')
 
@@ -12,9 +13,45 @@ class UCSHttpClient:
         self.ucs_http_address = ucs_http_address
 
     def schedule_ucs_manifest_import(self, manifest_id):
+        '''
+        Call this after glb, preview, manifest is posted into storage. Check status with check_process_status.
+        '''
         try:
+            # Inform UCS that it can start calculations
             ans = requests.get(f'{self.ucs_http_address}/api/import_manifest?man={manifest_id}')
+            # Record process_uuid with manifest_id into the database - to visualise the process
+            # (json)ans = {'data': {'process_uuid': '1003fd17-fee4-4522-9ece-f7b18f41237b'}}
+            process_data = ans.json()
+            process_uuid = process_data['data']['process_uuid']
+            db_query.register_ucs_process(manifest_id, process_uuid)
+
         except:
             log.exception(f'Error calling ucs to update by manifest = {manifest_id}')
 
+    def check_process_status(self, manifest_id):
+        '''
+        Check process status. Returns a dict with process status or None if the process is not registered.
+
+        {"data": {"process_report": {"is_finished": true, "result": {"metadata_effect": "8b1c29f611ffb30514ce6695c0da5abd",
+        "metadata_material": "af6f4eb6dc7ef0815c2815b042a86e10", "metadata_object": "ff29a721584335a92de79db1c289dbab",
+        "object_cid": "4a5f34dd54eea2d735b6155a885aaa81"}, "timeline": [["2022-04-04 20:46:11.099000", "PipeStepAddVars"],
+        ["2022-04-04 20:46:11.104000", "PipeStepAddVarsFromCallable"], ["2022-04-04 20:46:11.332000", "PipeStepGetManifestFromStorage"],
+        ["2022-04-04 20:46:11.338000", "PipeStepCreateUCSObject"], ["2022-04-04 20:46:11.343000", "PipeStepObjectMetadataFromManifest"],
+        ["2022-04-04 20:46:11.760000", "PipeStepLoadPreview"], ["2022-04-04 20:46:12.312000", "PipeStepCompressPreviews"],
+        ["2022-04-04 20:46:12.833000", "PipeStepCompressTextures"], ["2022-04-04 20:46:13.414000", "PipeStepCompressTextures"],
+        ["2022-04-04 20:46:13.419000", "PipeStepAddPreviewsToObjectMetadata"], ["2022-04-04 20:46:13.851000", "PipeStepLoadGLBFromManifest"],
+        ["2022-04-04 20:46:34.135000", "PipelineRepeated"]]}, "process_uuid": "1003fd17-fee4-4522-9ece-f7b18f41237b"}}
+        '''
+        process_data = db_query.get_ucs_process_uuid_by_class_id(manifest_id)
+        if process_data is None:
+            return None
+        process_uuid = process_data['process_uuid']
 
+        try:
+            ans = requests.get(f'{self.ucs_http_address}/api/process_status/{process_uuid}')
+            if ans.ok:
+                return ans.json()
+            else:
+                return None
+        except requests.exceptions.ConnectionError:
+            return None

src/ui/form.js

@@ -30,6 +30,7 @@ function FormUI() {
                 props: {
                   transformation: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
                 },
+                manually_set_block_cells: false
               },
             ],
             transformation: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
@@ -78,8 +79,10 @@ function FormUI() {
         e.preventDefault();
 
         const newCells = EventDispatcher.query("AssetsLoader.saveCells");
+        const cellsAreEdited = EventDispatcher.query("ToolUI.getBlockCellsEdited");
         if (newCells.length > 0) {
           AvvY.blockProps["properties"]["children"] = newCells;
+          AvvY.blockProps["properties"]["manually_set_block_cells"] = cellsAreEdited;
         }
 
         this.setProps(AvvY.blockProps, true);

src/ui/tools.js

@@ -21,6 +21,7 @@ function ToolUI() {
         opacity: 0.4,
     });
 
+    this.cellsAreEdited = false;
 
     const tempModalWrapper = document.getElementById("temp__tool");
     const modalWrapper = tempModalWrapper.content.getElementById("tool").cloneNode(true);
@@ -106,6 +107,9 @@ function ToolUI() {
           .catch((e) => {
             console.log(e);
           })
+
+        this.cellsAreEdited = true;
+
     });
 
     EventDispatcher.bind("mouse.click", this, function(e) {
@@ -118,6 +122,7 @@ function ToolUI() {
 
     EventDispatcher.bind("ToolUI.renderInfo", this, this.renderInfo);
     EventDispatcher.bind("ToolUI.resetTools", this, this.resetTools);
+    EventDispatcher.bind("ToolUI.getBlockCellsEdited", this, function() {return this.cellsAreEdited});
 
     const DOM_ELEMENT = EventDispatcher.query("Scene.getDomElement");
     DOM_ELEMENT.appendChild(this.view);
@@ -204,6 +209,8 @@ ToolUI.prototype.deleteOneCell = function(e) {
         } else {
             return null;
         }
+
+        this.cellsAreEdited = true;
     }
 }
 
@@ -226,6 +233,8 @@ ToolUI.prototype.addOneCell = function(e) {
         _cell.position.add(cell.face.normal).round();
         EventDispatcher.send("Scene.add", _cell);
         EventDispatcher.send("AssetsLoader.addCell", _cell.matrix.elements, _cell);
+
+        this.cellsAreEdited = true;
     }
 }
 

static/js/block_viewer.js

 (function ($) {
   "use strict";
 
+  // FILE IS DEPRECATED !!!
+
   const STORAGE_PATH = "https://storage.avvyland.com/storage";
 
   // const delCellBtn = document.getElementById("delete-cell");
@@ -279,7 +281,7 @@
             object_type: 3,
             props: {
               transformation: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
-            },
+            }
           },
         ],
         transformation: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
@@ -519,7 +521,6 @@ function saveCells() {
 submitBtn.addEventListener("click", e => {
   e.preventDefault();
   const newCells = saveCells();
-
   AvvY.blockProps["properties"]["children"] = newCells;
   inputBlockProps.value = JSON.stringify(AvvY.blockProps);
   approveForm.submit();

templates/block.html

@@ -54,6 +54,22 @@
                             {% else %}
                                 <a id="create-block" class="col-sm-3 btn btn-primary" href="#">Create Block</a>
                             {% end %}
+                            {% if has_ucs_process %}
+                                <h3>UCS process</h3>
+                                <div id="ucs_process" class="card-views mb-12" style="margin: 20px 0;">
+                                    {% if ucs_process_status["data"]["process_report"]["is_finished"] %}
+                                        Imported into UCS <br>
+                                        Celery uuid: {{ ucs_process_status["data"]["process_uuid"] }}
+                                    {% else %}
+                                        Celery uuid: {{ ucs_process_status["data"]["process_uuid"] }} <br>
+                                        Status: <br>
+                                        {% for dt_i in ucs_process_status["data"]["process_report"]["timeline"] %}
+                                            {{ dt_i[0] }} - {{ dt_i[1] }} <br>
+                                        {% end %}
+                                    {% end %}
+                                </div>
+
+                            {% end %}
                         <form id="approve-form" action="/block/{{ data["manifest"]["meta"]["id"] }}" method="post" enctype="multipart/form-data">
                             <div class="form-group">
                                 <div class="card-view__item">