Merge pull request #291 from hydraplatform/project_template_map

feat: add a project-template map table

Author: knoxsp

hydra_base/db/model/project.py

@@ -19,6 +19,7 @@
 from .base import *
 
 from .ownership import NetworkOwner, ProjectOwner
+from .template import ProjectTemplate
 from .scenario import Scenario, ResourceScenario
 from .permissions import User
 from .network import Network, ResourceAttr
@@ -62,6 +63,9 @@ class Project(Base, Inspect, PermissionControlled):
     layout = Column(JSON)
     user = relationship('User', backref=backref("projects", order_by=id))
 
+    templates = relationship('Template', secondary=ProjectTemplate.__table__,
+        backref=backref('projects', uselist=True))
+
     parent_id = Column(Integer(), ForeignKey('tProject.id'), nullable=True)
     parent = relationship('Project', remote_side=[id],
         backref=backref("children", order_by=id))

hydra_base/db/model/template.py

@@ -18,7 +18,7 @@
 #
 from .base import *
 
-__all__ = ['Template', 'TemplateType', 'TypeAttr', 'ResourceType']
+__all__ = ['Template', 'TemplateType', 'TypeAttr', 'ResourceType', 'ProjectTemplate']
 
 from .attributes import Attr
 from .units import Unit
@@ -323,6 +323,7 @@ def get_hierarchy(self, user_id):
             hierarchy = hierarchy + self.parent.get_hierarchy(user_id)
         return hierarchy
 
+
 class TemplateType(Base, Inspect):
     """
     Template Type
@@ -646,3 +647,17 @@ def get_templatetype(self):
         type_i = template_i.get_type(self.type_id)
 
         return JSONObject(type_i)
+
+class ProjectTemplate(Base, Inspect, PermissionControlled):
+    """
+    Links a template to a project, allowing template lookup at the project level.
+    """
+
+    __tablename__ = 'tProjectTemplate'
+
+    project_id = Column(Integer(), ForeignKey('tProject.id'), primary_key=True, nullable=False)
+    template_id = Column(Integer(), ForeignKey('tTemplate.id'), primary_key=True, nullable=False)
+    cr_date = Column(TIMESTAMP(), nullable=False, server_default=text(u'CURRENT_TIMESTAMP'))
+
+    _parents = ['tProject', 'tTemplate']
+    _children = []

hydra_base/lib/template/__init__.py

@@ -28,7 +28,8 @@
 from hydra_base import db
 from hydra_base.db.model import (Template, TemplateType, TypeAttr, Attr,
                                 Network, Node, Link, ResourceGroup,
-                                ResourceType, ResourceAttr, ResourceScenario, Scenario)
+                                ResourceType, ResourceAttr, ResourceScenario, Scenario,
+                                Project, ProjectTemplate)
 
 from hydra_base.db.model import Dataset as ModelDataset
 from hydra_base.lib.objects import JSONObject, Dataset
@@ -1359,3 +1360,93 @@ def get_all_parent_types(ttype_id, **kwargs):
     tt_qry = tt_qry.filter(TemplateType.id.in_(parent_ids))
     tt_qry = tt_qry.options(noload(TemplateType.typeattrs))
     return tt_qry.all()
+
+
+@required_perms("get_project")
+def get_project_templates(project_id, **kwargs):
+    """
+    Return all templates linked to a project.
+    The requesting user must have read access on the project.
+    """
+    user_id = kwargs.get('user_id')
+
+    try:
+        project_i = db.DBSession.query(Project).filter(Project.id == project_id).one()
+    except NoResultFound:
+        raise ResourceNotFoundError(f"Project {project_id} not found")
+
+    project_i.check_read_permission(user_id)
+
+    return project_i.templates
+
+
+@required_perms("edit_project")
+def add_project_template(project_id, template_id, **kwargs):
+    """
+    Link a template to a project.
+    The requesting user must have edit rights on the project.
+    """
+    user_id = kwargs.get('user_id')
+
+    try:
+        project_i = db.DBSession.query(Project).filter(Project.id == project_id).one()
+    except NoResultFound:
+        raise ResourceNotFoundError(f"Project {project_id} not found")
+
+    project_i.check_write_permission(user_id)
+
+    try:
+        db.DBSession.query(Template).filter(Template.id == template_id).one()
+    except NoResultFound:
+        raise ResourceNotFoundError(f"Template {template_id} not found")
+
+    existing = db.DBSession.query(ProjectTemplate).filter(
+        ProjectTemplate.project_id == project_id,
+        ProjectTemplate.template_id == template_id
+    ).first()
+
+    if existing is not None:
+        return existing
+
+    pt = ProjectTemplate()
+    pt.project_id = project_id
+    pt.template_id = template_id
+    db.DBSession.add(pt)
+    db.DBSession.flush()
+
+    log.info("Template %s linked to project %s", template_id, project_id)
+
+    return pt
+
+
+@required_perms("edit_project")
+def remove_project_template(project_id, template_id, **kwargs):
+    """
+    Remove the link between a template and a project.
+    The requesting user must have edit rights on the project.
+    """
+    user_id = kwargs.get('user_id')
+
+    try:
+        project_i = db.DBSession.query(Project).filter(Project.id == project_id).one()
+    except NoResultFound:
+        raise ResourceNotFoundError(f"Project {project_id} not found")
+
+    project_i.check_write_permission(user_id)
+
+    try:
+        pt = db.DBSession.query(ProjectTemplate).filter(
+            ProjectTemplate.project_id == project_id,
+            ProjectTemplate.template_id == template_id
+        ).one()
+    except NoResultFound:
+        raise ResourceNotFoundError(
+            f"Template {template_id} is not linked to project {project_id}"
+        )
+
+    db.DBSession.delete(pt)
+    db.DBSession.flush()
+
+    log.info("Template %s unlinked from project %s", template_id, project_id)
+
+    return 'OK'

tests/templates/test_templates.py

@@ -1207,3 +1207,65 @@ def test_type_compatibility(self, client, mock_template, mock_template_copy):
         assert len(errors_diff) == 1
         errors_same = client.check_type_compatibility(same_type_1_id, same_type_2_id)
         assert len(errors_same) == 0
+
+    def test_add_project_template(self, client, projectmaker, mock_template):
+        project = projectmaker.create()
+        pt = client.add_project_template(project.id, mock_template.id)
+        assert pt is not None
+        assert pt.project_id == project.id
+        assert pt.template_id == mock_template.id
+
+    def test_add_project_template_duplicate(self, client, projectmaker, mock_template):
+        """Adding the same link twice returns the existing record without error."""
+        project = projectmaker.create()
+        pt1 = client.add_project_template(project.id, mock_template.id)
+        pt2 = client.add_project_template(project.id, mock_template.id)
+        assert pt1.project_id == pt2.project_id
+        assert pt1.template_id == pt2.template_id
+
+    def test_add_project_template_invalid_project(self, client, mock_template):
+        with pytest.raises(Exception):
+            client.add_project_template(-999, mock_template.id)
+
+    def test_add_project_template_invalid_template(self, client, projectmaker):
+        project = projectmaker.create()
+        with pytest.raises(Exception):
+            client.add_project_template(project.id, -999)
+
+    def test_get_project_templates(self, client, projectmaker, mock_template):
+        project = projectmaker.create()
+        client.add_project_template(project.id, mock_template.id)
+        templates = client.get_project_templates(project.id)
+        assert templates is not None
+        template_ids = [t.id for t in templates]
+        assert mock_template.id in template_ids
+
+    def test_get_project_templates_empty(self, client, projectmaker):
+        """A project with no linked templates returns an empty list."""
+        project = projectmaker.create()
+        templates = client.get_project_templates(project.id)
+        assert len(templates) == 0
+
+    def test_get_project_templates_multiple(self, client, projectmaker, mock_template, mock_template_copy):
+        """Multiple templates can be linked to the same project."""
+        project = projectmaker.create()
+        client.add_project_template(project.id, mock_template.id)
+        client.add_project_template(project.id, mock_template_copy.id)
+        templates = client.get_project_templates(project.id)
+        template_ids = [t.id for t in templates]
+        assert mock_template.id in template_ids
+        assert mock_template_copy.id in template_ids
+
+    def test_remove_project_template(self, client, projectmaker, mock_template):
+        project = projectmaker.create()
+        client.add_project_template(project.id, mock_template.id)
+        result = client.remove_project_template(project.id, mock_template.id)
+        assert result == 'OK'
+        templates = client.get_project_templates(project.id)
+        assert mock_template.id not in [t.id for t in templates]
+
+    def test_remove_project_template_not_linked(self, client, projectmaker, mock_template):
+        """Removing a template that isn't linked to the project raises an error."""
+        project = projectmaker.create()
+        with pytest.raises(Exception):
+            client.remove_project_template(project.id, mock_template.id)