Added get/create endpoints, relationships now have same names as in blueprints

snorrefjellvang · snorrefjellvang · commit 29187d03e628 · 2023-10-09T15:30:25.000+02:00
diff --git a/data/study.json b/data/study.json
@@ -5,6 +5,7 @@
 			"name": "case1",
 			"type": "AppModels:signals_simple/Case",
 			"description": "",
+			"newAttribute": 32,
 			"duration": 100,
 			"timeStep": 0.1,
 			"components": [
diff --git a/models/signals_simple/Case.blueprint.json b/models/signals_simple/Case.blueprint.json
@@ -25,6 +25,11 @@
       "name": "duration",
       "type": "CORE:BlueprintAttribute",
       "attributeType": "number"
+    },
+        {
+      "name": "newAttribute",
+      "type": "CORE:BlueprintAttribute",
+      "attributeType": "number"
     },
     {
       "name": "timeStep",
diff --git a/plugin/api.py b/plugin/api.py
@@ -15,7 +15,7 @@
 
 
 @router.get('/{id}', response_model=Any)
-def get_data_by_id(id: UUID, table: str = None, levels: int = 1, all: bool = False,
+def get_data_by_id(id: UUID, table: str = None, levels: int = 1, all_data: bool = False,
                    session: Session = Depends(get_db_session)):
     engine = session.get_bind()
     metadata_obj = MetaData()
@@ -36,14 +36,15 @@ def get_data_by_id(id: UUID, table: str = None, levels: int = 1, all: bool = Fal
         result = session.execute(query).first()
         if result:
             for root, _, files in os.walk(os.path.join(os.path.dirname(__file__), '..', 'models')):
+
                 if f'{table}.blueprint.json' in files:
                     # Resolve model from table
                     bp = Blueprint.from_json(os.path.join(root, table))
                     model = resolve_model(bp)
 
                     # Get top level data
                     parent_alias = aliased(model)
-                    if all:
+                    if all_data:
                         #Fetches parent and all children to bottom
                         parent_alias = aliased(model)
                         return jsonable_encoder((
@@ -76,3 +77,68 @@ def get_data_by_id(id: UUID, table: str = None, levels: int = 1, all: bool = Fal
                             break
                     return jsonable_encoder(top)
     raise HTTPException(status_code=404, detail=f"Could not find ID {id}")
+
+
+@router.post('/', response_model=Any)
+def create_entity(entity: dict, return_all: bool = False, session: Session = Depends(get_db_session)):
+    def create_entity_recursive(entity, is_toplevel, session):
+        try:
+            table = entity['type'].rsplit('/')[1]
+        except AttributeError:
+            HTTPException(status_code=400, detail=f"Invalid input, BP should be available as attribute: type")
+        for root, _, files in os.walk(os.path.join(os.path.dirname(__file__), '..', 'models')):
+            if f'{table}.blueprint.json' in files:
+                # Resolve model from table
+                bp = Blueprint.from_json(os.path.join(root, table))
+                model = resolve_model(bp)
+
+                data_table = {}
+                children = []
+                children_rel_names = []
+                data = dict()
+                for key, value in entity.items():
+                    attr = [attr for attr in bp.attributes if attr.name == key][0]
+                    if attr.name == 'type':
+                        continue
+                    if attr.attributeType.lower() in ["string", "integer", "number", "float", "boolean", "foreign_key", "type",
+                                                      "core:blueprintattribute"]:
+                        if hasattr(attr, 'dimensions') and attr.dimensions == '*':
+                            data_table[key] = value
+                        else:
+                            data[key] = value
+                    else:
+                        if isinstance(value, list):
+                            children.extend(value)
+                            [children_rel_names.append(key) for _ in value]
+                        elif isinstance(value, dict):
+                            children.append(value)
+                            children_rel_names.append(key)
+                        else:
+                            raise NotImplementedError(f'Type {type(value)} not supported yet')
+
+                obj_in_data = jsonable_encoder(data)
+                db_obj = model(**obj_in_data)
+                for child, rel_name in zip(children, children_rel_names):
+                    child_obj = create_entity_recursive(child, False, session)
+                    getattr(db_obj, rel_name).append(child_obj)
+
+                for key, value in data_table.items():
+                    data_table_model = resolve_model(bp, key)
+                    data_table_objects = [data_table_model(data=item) for item in value]
+                    getattr(db_obj, key).extend(data_table_objects)
+
+                session.add(db_obj)
+                session.commit()
+                session.refresh(db_obj)
+                if is_toplevel:
+                    return jsonable_encoder(db_obj)
+                else:
+                    return db_obj
+
+            HTTPException(status_code=404, detail=f"Could not find Blueprint {table}")
+    new_obj = create_entity_recursive(entity, True, session)
+    #Re-use get_endpoint to fetch all nested objects
+    if return_all:
+        new_id = create_entity_recursive(entity, True, session)['id']
+        return get_data_by_id(id=new_id, all_data=True, session=session)
+    return new_obj
diff --git a/plugin/config.py b/plugin/config.py
@@ -7,4 +7,4 @@ class Config(BaseSettings):
     """
     Application configuration
     """
-    SQLALCHEMY_DATABASE_URI: str = Field(' ', validation_alias='SQLALCHEMY_DATABASE_URI')
+    SQLALCHEMY_DATABASE_URI: str = Field('', validation_alias='SQLALCHEMY_DATABASE_URI')
diff --git a/plugin/crud/__init__.py b/plugin/crud/__init__.py
@@ -13,6 +13,7 @@ def create_entity(db: Session, entity: dict, commit=True) -> dict:
 
     data_table = {}
     children = []
+    children_rel_names = []
     data = dict()
     for key, value in entity.items():
         attr = [attr for attr in bp.attributes if attr.name == key][0]
@@ -27,17 +28,19 @@ def create_entity(db: Session, entity: dict, commit=True) -> dict:
         else:
             if isinstance(value, list):
                 children.extend(value)
+                [children_rel_names.append(key) for _ in value]
             elif isinstance(value, dict):
                 children.append(value)
+                children_rel_names.append(key)
             else:
                 raise NotImplementedError(f'Type {type(value)} not supported yet')
 
     obj_in_data = jsonable_encoder(data)
     db_obj = model(**obj_in_data)
 
-    for child in children:
+    for child, rel_name in zip(children,  children_rel_names):
         child_obj = create_entity(db, child, commit=True)
-        getattr(db_obj, f'{child_obj.__table__.key}_s').append(child_obj)
+        getattr(db_obj, rel_name).append(child_obj)
 
     for key, value in data_table.items():
         data_table_model = resolve_model(bp, key)
diff --git a/plugin/database.py b/plugin/database.py
@@ -3,37 +3,17 @@
 from config import Config
 from plugin import models
 
-
 engine = None
 
 
-def init_engine(config=Config(), **kwargs):
-    """Initiate database engine."""
-    global engine
-    engine = create_engine(config.SQLALCHEMY_DATABASE_URI, **kwargs)
-    return engine
-
-
 def get_db_session():
     """
     Create an independent database session/connection per request. Use the same session through all the request and
     then close it after the request is finished.
     """
-    session_factory = sessionmaker(autocommit=False, autoflush=False, bind=init_engine())
-    session = session_factory()
-    try:
-        yield session
-    finally:
-        session.close()
-
+    config = Config()
+    engine = create_engine(config.SQLALCHEMY_DATABASE_URI, pool_pre_ping=True, executemany_mode="values_plus_batch")
+    models.Base.metadata.create_all(bind=engine)
 
-# def get_db_session(config=Config()):
-#     """
-#     Create an independent database session/connection per request. Use the same session through all the request and
-#     then close it after the request is finished.
-#     """
-#     engine = create_engine(config.SQLALCHEMY_DATABASE_URI, pool_pre_ping=True, executemany_mode="values_plus_batch")
-#     models.Base.metadata.create_all(bind=engine)
-#
-#     with Session(engine) as session:
-#         return session
+    with Session(engine) as session:
+        return session
diff --git a/plugin/dev2.py b/plugin/dev2.py
@@ -5,7 +5,7 @@
 
 #initialize_database
 #base_folder = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', "models"))
-initialize_database(base_folder=base_folder)
+#initialize_database(base_folder=base_folder)
 
 
 # fill with data
diff --git a/plugin/models/blueprint_handling.py b/plugin/models/blueprint_handling.py
@@ -102,7 +102,7 @@ def generate_models_m2m_rel(self, parent: str = None):
                 children.append(child_blueprint)
                 child_name = child_blueprint.name
                 # todo: cascade delete on contained = True
-                class_attributes[f'{child_name}_s'] = relationship(child_name,
+                class_attributes[f'{attr_name}'] = relationship(child_name,
                                                                    secondary=f'{self.name}_{child_name}_map',
                                                                    cascade="all,delete")
         if parent:
