Update organisation (#507)

Author: Taniya-Das

alembic/alembic/versions/5d0d73539c21_add_organisation_turnover_and_n_employees.py

@@ -0,0 +1,52 @@
+"""Add organisation.turnover and organisation.number_of_employees
+
+Revision ID: 5d0d73539c21
+Revises: 1662d64ebe23
+Create Date: 2025-05-12 14:00:35.644646
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "5d0d73539c21"
+down_revision: Union[str, None] = "751c3f34323a"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade():
+    op.add_column("organisation", sa.Column("turnover_identifier", sa.Integer(), nullable=True))
+    op.add_column(
+        "organisation", sa.Column("number_of_employees_identifier", sa.Integer(), nullable=True)
+    )
+
+    op.create_foreign_key(
+        "fk_organisation_turnover_identifier",
+        "organisation",
+        "turnover",
+        ["turnover_identifier"],
+        ["identifier"],
+    )
+
+    op.create_foreign_key(
+        "fk_organisation_number_of_employees_identifier",
+        "organisation",
+        "number_of_employees",
+        ["number_of_employees_identifier"],
+        ["identifier"],
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint(
+        "fk_organisation_number_of_employees_identifier", "organisation", type_="foreignkey"
+    )
+    op.drop_constraint("fk_organisation_turnover_identifier", "organisation", type_="foreignkey")
+
+    op.drop_column("organisation", "number_of_employees_identifier")
+    op.drop_column("organisation", "turnover_identifier")

src/database/model/agent/organisation.py

@@ -1,8 +1,9 @@
 from datetime import date
-from typing import Optional
+from typing import Optional, Literal
 
 from sqlmodel import Field, Relationship
 
+from database.model.named_relation import Taxonomy, create_taxonomy
 from database.model.agent.agent import AgentBase, Agent
 from database.model.agent.agent_table import AgentTable
 from database.model.agent.contact import Contact
@@ -18,6 +19,13 @@
 )
 
 
+Turnover: type[Taxonomy] = create_taxonomy(class_name="Turnover", table_name="turnover")
+
+NumberOfEmployees: type[Taxonomy] = create_taxonomy(
+    class_name="NumberOfEmployees", table_name="number_of_employees"
+)
+
+
 class OrganisationBase(AgentBase):
     date_founded: date | None = Field(
         description="The date on which the organisation was founded.",
@@ -54,6 +62,20 @@ class Organisation(OrganisationBase, Agent, table=True):  # type: ignore [call-a
         ),
     )
 
+    turnover_identifier: int | None = Field(
+        default=None,
+        foreign_key="turnover.identifier",
+        description="The revenue bracket of the organisation.",
+    )
+    turnover: Optional[Turnover] = Relationship()  # type: ignore[valid-type]
+
+    number_of_employees_identifier: int | None = Field(
+        default=None,
+        foreign_key="number_of_employees.identifier",
+        description="The employee size bracket of the organisation.",
+    )
+    number_of_employees: Optional[NumberOfEmployees] = Relationship()  # type: ignore[valid-type]
+
     class RelationshipConfig(Agent.RelationshipConfig):
         contact_details: str | None = OneToOne(
             description="The identifier of the contact details by which this organisation "
@@ -76,6 +98,24 @@ class RelationshipConfig(Agent.RelationshipConfig):
             default_factory_pydantic=list,
         )
 
+        turnover: Optional[str] = ManyToOne(
+            description="The approximate revenue bracket of the organisation in euros, see the taxonomy for more details.",
+            identifier_name="turnover_identifier",
+            _serializer=AttributeSerializer("name"),
+            deserializer=FindByNameDeserializer(Turnover),
+            example=">5 million euros",
+        )
+
+        number_of_employees: Optional[str] = ManyToOne(
+            description=(
+                "The number of employees of the organisation, see the taxonomy for more details."
+            ),
+            identifier_name="number_of_employees_identifier",
+            _serializer=AttributeSerializer("name"),
+            deserializer=FindByNameDeserializer(NumberOfEmployees),
+            example="<10",
+        )
+
 
 deserializer = FindByIdentifierDeserializer(Organisation)
 Contact.RelationshipConfig.organisation.deserializer = deserializer  # type: ignore

src/taxonomies/synchronize_taxonomy.py

@@ -15,6 +15,7 @@
 from database.model.ai_resource.industrial_sector import IndustrialSector
 from database.model.ai_resource.scientific_domain import ScientificDomain
 from database.model.news.news_category import NewsCategory
+from database.model.agent.organisation import NumberOfEmployees, Turnover
 
 
 def parse_args():
@@ -40,6 +41,8 @@ class Term(NamedTuple):
     "Licence": License,
     "News Category": NewsCategory,
     "Scientific Domain": ScientificDomain,
+    "Number of Employees": NumberOfEmployees,
+    "Turnover": Turnover,
 }
 
 

src/tests/routers/generic/test_router_post.py

@@ -2,7 +2,8 @@
 import pytest
 from starlette.testclient import TestClient
 
-from tests.testutils.users import logged_in_user, kc_connector_with_roles, kc_user_with_roles
+from tests.testutils.users import logged_in_user, kc_connector_with_roles
+from tests.routers.resource_routers.test_router_organisation import with_organisation_taxonomies
 from database.model.platform.platform_names import PlatformName
 from database.model.resource_read_and_create import resource_create
 from routers import resource_routers
@@ -237,7 +238,7 @@ def test_taxonomy_is_not_enforced_for_connector(
     tested_routers := [r for r in resource_routers.router_list if r.resource_name != 'platform'],
     ids=map(lambda r: r.resource_name, tested_routers),
 )
-def test_example_is_valid(router, client: TestClient):
+def test_example_is_valid(router, client: TestClient, with_organisation_taxonomies):
     example_values = {}
     res_create = resource_create(router.resource_class)
     for attribute, model_field in res_create.__fields__.items():

src/tests/routers/generic/test_taxonomies.py

@@ -0,0 +1,30 @@
+import copy
+from http import HTTPStatus
+
+import pytest
+
+from tests.routers.resource_routers.test_router_organisation import with_organisation_taxonomies
+from tests.testutils.users import logged_in_user
+
+
+@pytest.mark.parametrize(
+    ("field", "value"),
+    [
+        ("turnover", "foo"),
+        ("number_of_employees", "foo"),
+    ]
+)
+def test_invalid_value_is_rejected(field, value, body_agent, client, with_organisation_taxonomies):
+    organisation = copy.copy(body_agent)
+    organisation[field] = value
+
+    with logged_in_user():
+        response = client.post(
+            "/organisations",
+            json=organisation,
+            headers={"Authorization": "Fake token"},
+        )
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    assert "not part of the taxonomy" in response.json()["detail"]
+    assert field in response.json()["detail"]
+    assert value in response.json()["detail"]

src/tests/routers/resource_routers/test_router_organisation.py

@@ -4,9 +4,37 @@
 from starlette.testclient import TestClient
 
 from database.model.agent.contact import Contact
-from database.model.agent.organisation import Organisation
+from database.model.agent.organisation import Organisation, Turnover,NumberOfEmployees
 from database.session import DbSession
 
+import pytest
+
+from taxonomies.synchronize_taxonomy import synchronize
+
+STANDARD_TURNOVER_VALUES = ["<1 million euros", ">1 million euros", ">3 million euros", ">5 million euros", ">50 million euros", ">1.5 billion euros"]
+
+@pytest.fixture
+def with_organisation_taxonomies():
+    with DbSession() as session:
+        synchronize(
+            NumberOfEmployees,
+            [
+                NumberOfEmployees(name=value,definition="", official=True, children=[])
+                for value in ["<10", "<50", "<250", ">=250"]
+            ],
+            session
+        )
+        synchronize(
+            Turnover,
+            [
+                Turnover(name=value,definition="", official=True, children=[])
+                for value in STANDARD_TURNOVER_VALUES
+            ],
+            session
+        )
+        session.commit()
+    yield
+
 
 def test_happy_path(
     client: TestClient,
@@ -15,12 +43,14 @@ def test_happy_path(
     contact: Contact,
     body_agent: dict,
     auto_publish: None,
+    with_organisation_taxonomies,
 ):
     body = copy.copy(body_agent)
     body["date_founded"] = "2023-01-01"
     body["legal_name"] = "A name for the organisation"
     body["ai_relevance"] = "Part of CLAIRE"
     body["type"] = "Research Institute"
+    body["turnover"] = "<1 million euros"
     with DbSession() as session:
         session.add(organisation)  # The new organisation will be a member of this organisation
         session.add(contact)
@@ -46,6 +76,7 @@ def test_happy_path(
     assert response_json["legal_name"] == "A name for the organisation"
     assert response_json["ai_relevance"] == "Part of CLAIRE"
     assert response_json["type"] == "research institute"
+    assert response_json["turnover"] == "<1 million euros"
     assert response_json["member"] == body["member"]
     assert response_json["contact_details"] == body["contact_details"]
     assert response_json["contacts"][0]["name"] == "Aaron Bar"
@@ -71,6 +102,12 @@ def test_happy_path(
     response = client.get(f"organisations/{identifier}")
     assert response.json()["type"] == "association"
 
+    body["number_of_employees"] = "<50"
+    response = client.put(f"organisations/{identifier}", json=body, headers={"Authorization": "Fake token"})
+    assert response.status_code == 200, response.json()
+    response = client.get(f"organisations/{identifier}")
+    assert response.json()["number_of_employees"] == "<50"
+
     response = client.delete(f"/organisations/{identifier}", headers={"Authorization": "Fake token"})
     assert response.status_code == 200, response.json()
 

src/tests/testutils/default_sqlalchemy.py

@@ -20,7 +20,6 @@
 from database.model.platform.platform_names import PlatformName
 from database.session import EngineSingleton
 from main import build_app
-from database.model.ai_resource.application_area import ApplicationArea
 from database.model.ai_resource.industrial_sector import IndustrialSector
 from database.model.ai_resource.research_area import ResearchArea
 from database.model.ai_resource.scientific_domain import ScientificDomain