canvas 0.27.0__py3-none-any.whl → 0.29.0__py3-none-any.whl

canvas_generated/messages/events_pb2.pyi

@@ -786,6 +786,8 @@ class EventType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
     PATIENT_PORTAL__APPOINTMENTS__FORM_LOCATIONS__POST_SEARCH: _ClassVar[EventType]
     PATIENT_PORTAL__APPOINTMENTS__FORM_PROVIDERS__PRE_SEARCH: _ClassVar[EventType]
     PATIENT_PORTAL__APPOINTMENTS__FORM_PROVIDERS__POST_SEARCH: _ClassVar[EventType]
+    PATIENT_PORTAL__APPOINTMENT_CAN_SHOW_MEETING_LINK: _ClassVar[EventType]
+    PATIENT_PORTAL__GET_APPLICATION_CONFIGURATION: _ClassVar[EventType]
     PATIENT_PORTAL__MENU_CONFIGURATION: _ClassVar[EventType]
     PATIENT_PORTAL__WIDGET_CONFIGURATION: _ClassVar[EventType]
     SHOW_CHART_SUMMARY_SOCIAL_DETERMINANTS_SECTION_BUTTON: _ClassVar[EventType]
@@ -1578,6 +1580,8 @@ PATIENT_PORTAL__APPOINTMENTS__FORM_LOCATIONS__PRE_SEARCH: EventType
 PATIENT_PORTAL__APPOINTMENTS__FORM_LOCATIONS__POST_SEARCH: EventType
 PATIENT_PORTAL__APPOINTMENTS__FORM_PROVIDERS__PRE_SEARCH: EventType
 PATIENT_PORTAL__APPOINTMENTS__FORM_PROVIDERS__POST_SEARCH: EventType
+PATIENT_PORTAL__APPOINTMENT_CAN_SHOW_MEETING_LINK: EventType
+PATIENT_PORTAL__GET_APPLICATION_CONFIGURATION: EventType
 PATIENT_PORTAL__MENU_CONFIGURATION: EventType
 PATIENT_PORTAL__WIDGET_CONFIGURATION: EventType
 SHOW_CHART_SUMMARY_SOCIAL_DETERMINANTS_SECTION_BUTTON: EventType

canvas_sdk/commands/commands/perform.py

@@ -8,5 +8,5 @@ class PerformCommand(BaseCommand):
         key = "perform"
         commit_required_fields = ("cpt_code",)
 
-    cpt_code: str
+    cpt_code: str | None = None
     notes: str | None = None

canvas_sdk/effects/patient_portal/application_configuration.py

@@ -0,0 +1,22 @@
+from typing import Any
+
+from canvas_sdk.effects.base import EffectType, _BaseEffect
+
+
+class PatientPortalApplicationConfiguration(_BaseEffect):
+    """An effect to configure patient portal application."""
+
+    class Meta:
+        effect_type = EffectType.PATIENT_PORTAL__APPLICATION_CONFIGURATION
+
+    can_schedule_appointments: bool
+
+    @property
+    def values(self) -> dict[str, Any]:
+        """Application Configuration values."""
+        return {"can_schedule_appointments": self.can_schedule_appointments}
+
+    @property
+    def effect_payload(self) -> dict[str, Any]:
+        """The payload of the effect."""
+        return {"data": self.values}

canvas_sdk/effects/show_button.py

@@ -16,11 +16,12 @@ class ShowButtonEffect(_BaseEffect):
 
     key: str = Field(min_length=1)
     title: str = Field(min_length=1)
+    priority: int = Field(default=0)
 
     @property
     def values(self) -> dict[str, Any]:
         """The ShowButtonEffect's values."""
-        return {"key": self.key, "title": self.title}
+        return {"key": self.key, "title": self.title, "priority": self.priority}
 
     @property
     def effect_payload(self) -> dict[str, Any]:

canvas_sdk/effects/simple_api.py

@@ -1,13 +1,13 @@
 import json
 from base64 import b64encode
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from http import HTTPStatus
 from typing import Any
 
 from canvas_generated.messages.effects_pb2 import EffectType
 from canvas_sdk.effects import Effect, _BaseEffect
 
-JSON = dict[str, "JSON"] | list["JSON"] | int | float | str | bool | None
+JSON = Mapping[str, "JSON"] | Sequence["JSON"] | int | float | str | bool | None
 
 
 class Response(_BaseEffect):

canvas_sdk/handlers/action_button.py

@@ -48,6 +48,7 @@ class ActionButton(BaseHandler):
     BUTTON_TITLE: str = ""
     BUTTON_KEY: str = ""
     BUTTON_LOCATION: ButtonLocation
+    PRIORITY: int = 0
 
     @abstractmethod
     def handle(self) -> list[Effect]:
@@ -68,7 +69,11 @@ class ActionButton(BaseHandler):
         if show_button_event_match:
             location = show_button_event_match.group(1)
             if self.ButtonLocation[location] == self.BUTTON_LOCATION and self.visible():
-                return [ShowButtonEffect(key=self.BUTTON_KEY, title=self.BUTTON_TITLE).apply()]
+                return [
+                    ShowButtonEffect(
+                        key=self.BUTTON_KEY, title=self.BUTTON_TITLE, priority=self.PRIORITY
+                    ).apply()
+                ]
         elif self.context["key"] == self.BUTTON_KEY:
             return self.handle()
 

canvas_sdk/handlers/simple_api/api.py

@@ -1,4 +1,5 @@
 import json
+import re
 import traceback
 from abc import ABC
 from base64 import b64decode
@@ -9,7 +10,7 @@ from typing import Any, ClassVar, Protocol, TypeVar, cast
 from urllib.parse import parse_qsl
 
 from canvas_sdk.effects import Effect, EffectType
-from canvas_sdk.effects.simple_api import JSONResponse, Response
+from canvas_sdk.effects.simple_api import JSON, JSONResponse, Response
 from canvas_sdk.events import Event, EventType
 from canvas_sdk.handlers.base import BaseHandler
 from logger import log
@@ -19,14 +20,6 @@ from .exceptions import AuthenticationError, InvalidCredentialsError
 from .security import Credentials
 from .tools import CaseInsensitiveMultiDict, MultiDict, separate_headers
 
-# TODO: Routing by path regex?
-# TODO: Log requests in a format similar to other API frameworks (probably need effect metadata)
-# TODO: Support Effect metadata that is separate from payload
-# TODO: Encode event payloads with MessagePack instead of JSON
-
-
-JSON = dict[str, "JSON"] | list["JSON"] | int | float | str | bool | None
-
 
 class FormPart(Protocol):
     """
@@ -162,13 +155,16 @@ def parse_multipart_form(form: bytes, boundary: str) -> MultiDict[str, FormPart]
 class Request:
     """Request class for incoming requests to the API."""
 
-    def __init__(self, event: Event) -> None:
+    def __init__(self, event: Event, path_pattern: re.Pattern) -> None:
         self.method = event.context["method"]
         self.path = event.context["path"]
         self.query_string = event.context["query_string"]
         self._body = event.context["body"]
         self.headers = CaseInsensitiveMultiDict(separate_headers(event.context["headers"]))
 
+        match = path_pattern.match(event.context["path"])
+        self.path_params = match.groupdict() if match else {}
+
         self.query_params = MultiDict(parse_qsl(self.query_string))
 
         # Parse the content type and any included content type parameters
@@ -266,7 +262,8 @@ class SimpleAPIBase(BaseHandler, ABC):
         EventType.Name(EventType.SIMPLE_API_REQUEST),
     ]
 
-    _ROUTES: ClassVar[dict[tuple[str, str], RouteHandler]]
+    _ROUTES: ClassVar[dict[str, list[tuple[re.Pattern, RouteHandler]]]]
+    _PATH_PARAM_REGEX = re.compile("<([a-zA-Z_][a-zA-Z0-9_]*)>")
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
@@ -279,7 +276,30 @@ class SimpleAPIBase(BaseHandler, ABC):
             if callable(attr) and (route := getattr(attr, "route", None)):
                 method, relative_path = route
                 path = f"{cls._path_prefix()}{relative_path}"
-                cls._ROUTES[(method, path)] = attr
+
+                # Convert the path to a regular expression pattern so that any path parameters can
+                # be extracted later
+                try:
+                    path_pattern = re.compile(path.replace("<", "(?P<").replace(">", ">[^/]+)"))
+                except re.error as error:
+                    raise PluginError(
+                        f"Path parameter names in route '{path}' must be unique"
+                    ) from error
+
+                cls._ROUTES.setdefault(method, [])
+                cls._ROUTES[method].append((path_pattern, attr))
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+        # Determine the first handler that matches the path based on the path pattern
+        self._path_pattern = None
+        self._handler = None
+        for path_pattern, handler in self._ROUTES.get(self.event.context["method"], ()):
+            if path_pattern.match(self.event.context["path"]):
+                self._path_pattern = path_pattern
+                self._handler = handler
+                break
 
     @classmethod
     def _path_prefix(cls) -> str:
@@ -288,7 +308,7 @@ class SimpleAPIBase(BaseHandler, ABC):
     @cached_property
     def request(self) -> Request:
         """Return the request object from the event."""
-        return Request(self.event)
+        return Request(self.event, cast(re.Pattern, self._path_pattern))
 
     def compute(self) -> list[Effect]:
         """Handle the authenticate or request event."""
@@ -313,8 +333,8 @@ class SimpleAPIBase(BaseHandler, ABC):
             credentials_cls = self.authenticate.__annotations__.get("credentials")
             if not credentials_cls or not issubclass(credentials_cls, Credentials):
                 raise PluginError(
-                    "Cannot determine authentication scheme; please specify the type of "
-                    "credentials your endpoint requires"
+                    f"Cannot determine authentication scheme for {self.request.path}; "
+                    "please specify the type of credentials your endpoint requires"
                 )
             credentials = credentials_cls(self.request)
 
@@ -334,11 +354,8 @@ class SimpleAPIBase(BaseHandler, ABC):
 
     def _handle_request(self) -> list[Effect]:
         """Route the incoming request to the handler method based on the HTTP method and path."""
-        # Get the handler method
-        handler = self._ROUTES[(self.request.method, self.request.path)]
-
         # Handle the request
-        effects = handler(self)
+        effects = cast(RouteHandler, self._handler)(self)
 
         # Iterate over the returned effects and:
         # 1. Change any response objects to response effects
@@ -377,7 +394,7 @@ class SimpleAPIBase(BaseHandler, ABC):
 
     def accept_event(self) -> bool:
         """Ignore the event if the handler does not implement the route."""
-        return (self.request.method, self.request.path) in self._ROUTES
+        return self._handler is not None
 
     def authenticate(self, credentials: Credentials) -> bool:
         """Method the user should override to authenticate requests."""

canvas_sdk/tests/handlers/test_simple_api.py

@@ -1,4 +1,5 @@
 import json
+import re
 from base64 import b64decode, b64encode
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from http import HTTPStatus
@@ -242,7 +243,8 @@ def test_request(
     path = "/route"
     query_string = "value1=a&value2=b"
     request = Request(
-        make_event(EventType.SIMPLE_API_REQUEST, method, path, query_string, body, headers)
+        make_event(EventType.SIMPLE_API_REQUEST, method, path, query_string, body, headers),
+        path_pattern=re.compile(path),
     )
 
     assert request.method == method
@@ -317,7 +319,8 @@ def test_request_form(
             path="/route",
             body=body,
             headers={"Content-Type": content_type},
-        )
+        ),
+        path_pattern=re.compile("/route"),
     )
 
     assert request.form_data() == expected_form_data
@@ -435,6 +438,112 @@ def test_request_routing_api(
     assert body["method"] == method
 
 
+@pytest.mark.parametrize(
+    argnames="prefix_pattern,path_pattern,body_func,path,expected_body",
+    argvalues=[
+        (
+            "/prefix",
+            "/path/<param>",
+            lambda params: {"param": params["param"]},
+            "/prefix/path/value",
+            {"param": "value"},
+        ),
+        (
+            "/prefix",
+            "/path1/<param1>/path2/<param2>",
+            lambda params: {"param1": params["param1"], "param2": params["param2"]},
+            "/prefix/path1/value1/path2/value2",
+            {"param1": "value1", "param2": "value2"},
+        ),
+        (
+            "/prefix/<param>",
+            "/path",
+            lambda params: {"param": params["param"]},
+            "/prefix/value/path",
+            {"param": "value"},
+        ),
+        (
+            "/<param1>/prefix/<param2>",
+            "/path",
+            lambda params: {"param1": params["param1"], "param2": params["param2"]},
+            "/value1/prefix/value2/path",
+            {"param1": "value1", "param2": "value2"},
+        ),
+        (
+            "/prefix/<param1>",
+            "/path/<param2>",
+            lambda params: {"param1": params["param1"], "param2": params["param2"]},
+            "/prefix/value1/path/value2",
+            {"param1": "value1", "param2": "value2"},
+        ),
+    ],
+    ids=[
+        "single parameter in path",
+        "multiple parameters in path",
+        "single parameter in prefix",
+        "multiple parameters in prefix",
+        "parameters in path and prefix",
+    ],
+)
+def test_request_routing_path_pattern(
+    prefix_pattern: str,
+    path_pattern: str,
+    body_func: Callable[[Mapping[str, str]], Mapping[str, str]],
+    path: str,
+    expected_body: Mapping[str, str],
+) -> None:
+    """Test Request routing for routes that use path patterns."""
+
+    class API(APINoAuth):
+        PREFIX = prefix_pattern
+
+        @api.get(path_pattern)
+        def route(self) -> list[Response | Effect]:
+            return [JSONResponse(body_func(self.request.path_params))]
+
+    effects = handle_request(API, "GET", path=path)
+    body = json_response_body(effects)
+
+    assert body == expected_body
+
+
+@pytest.mark.parametrize(
+    argnames="path_pattern1,path_pattern2,path,expected_body",
+    argvalues=[
+        ("/path/<value>", "/path/test", "/prefix/path/value", {"handler_method": "first"}),
+        ("/path/<value>", "/path/test", "/prefix/path/test", {"handler_method": "first"}),
+        ("/path/test", "/path/<value>", "/prefix/path/test", {"handler_method": "first"}),
+        ("/path/test", "/path/<value>", "/prefix/path/value", {"handler_method": "second"}),
+    ],
+    ids=[
+        "pattern registered first, path matches only pattern",
+        "pattern registered first, path matches both pattern and fixed",
+        "fixed registered first, path matches both pattern and fixed",
+        "fixed registered first, path matches only pattern",
+    ],
+)
+def test_request_routing_path_pattern_multiple_matches(
+    path_pattern1: str, path_pattern2: str, path: str, expected_body: Mapping[str, str]
+) -> None:
+    """Test request routing for path patterns where a path matches multiple routes in a handler."""
+
+    class API(APINoAuth):
+        PREFIX = "/prefix"
+
+        @api.get(path_pattern1)
+        def route1(self) -> list[Response | Effect]:
+            return [JSONResponse({"handler_method": "first"})]
+
+        @api.get(path_pattern2)
+        def route2(self) -> list[Response | Effect]:
+            return [JSONResponse({"handler_method": "second"})]
+
+    effects = handle_request(API, "GET", path=path)
+    body = json_response_body(effects)
+
+    assert body == expected_body
+
+
 def test_request_lifecycle() -> None:
     """Test the request-response lifecycle."""
 
@@ -700,6 +809,17 @@ def test_invalid_path_error() -> None:
                 return []
 
 
+def test_invalid_path_pattern_error() -> None:
+    """Test the enforcement of the error that occurs when a route has an invalid path pattern."""
+    with pytest.raises(PluginError):
+
+        class Route(RouteNoAuth):
+            PATH = "/path1/<value>/<path2>/<value>"
+
+            def get(self) -> list[Response | Effect]:
+                return []
+
+
 def test_route_missing_path_error() -> None:
     """
     Test the enforcement of the error that occurs when a SimpleAPIRoute is missing a PATH value.

canvas_sdk/utils/http.py

@@ -1,6 +1,7 @@
 import concurrent
 import functools
 import time
+import urllib.parse
 from collections.abc import Callable, Iterable, Mapping
 from concurrent.futures import ThreadPoolExecutor
 from functools import wraps
@@ -94,10 +95,35 @@ def batch_patch(
 class Http:
     """A helper class for completing HTTP calls with metrics tracking."""
 
-    _MAX_WORKER_TIMEOUT_SECONDS = 30
+    _MAX_REQUEST_TIMEOUT_SECONDS = 30
+
+    base_url: str
+    session: requests.Session
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """
+        Prevent base_url or session from being updated after initialization.
+        """
+        if name in ("base_url", "session"):
+            raise AttributeError(f"{name} is read-only")
+
+        super().__setattr__(name, value)
+
+    def join_url(self, url: str) -> str:
+        """
+        Join a URL to the base_url.
+        """
+        joined = urllib.parse.urljoin(self.base_url, url)
+
+        if not joined.startswith(self.base_url):
+            raise ValueError("You may not access other URLs using this client.")
+
+        return joined
+
+    def __init__(self, base_url: str = "") -> None:
+        super().__setattr__("base_url", base_url)
+        super().__setattr__("session", requests.Session())
 
-    def __init__(self) -> None:
-        self.session = requests.Session()
         self.statsd_client = statsd.StatsClient()
 
     @staticmethod
@@ -122,7 +148,11 @@ class Http:
         """Sends a GET request."""
         if headers is None:
             headers = {}
-        return self.session.get(url, headers=headers)
+        return self.session.get(
+            self.join_url(url),
+            headers=headers,
+            timeout=self._MAX_REQUEST_TIMEOUT_SECONDS,
+        )
 
     @measure_time
     def post(
@@ -133,7 +163,13 @@ class Http:
         headers: Mapping[str, str | bytes | None] | None = None,
     ) -> requests.Response:
         """Sends a POST request."""
-        return self.session.post(url, json=json, data=data, headers=headers)
+        return self.session.post(
+            self.join_url(url),
+            json=json,
+            data=data,
+            headers=headers,
+            timeout=self._MAX_REQUEST_TIMEOUT_SECONDS,
+        )
 
     @measure_time
     def put(
@@ -144,7 +180,13 @@ class Http:
         headers: Mapping[str, str | bytes | None] | None = None,
     ) -> requests.Response:
         """Sends a PUT request."""
-        return self.session.put(url, json=json, data=data, headers=headers)
+        return self.session.put(
+            self.join_url(url),
+            json=json,
+            data=data,
+            headers=headers,
+            timeout=self._MAX_REQUEST_TIMEOUT_SECONDS,
+        )
 
     @measure_time
     def patch(
@@ -155,7 +197,13 @@ class Http:
         headers: Mapping[str, str | bytes | None] | None = None,
     ) -> requests.Response:
         """Sends a PATCH request."""
-        return self.session.patch(url, json=json, data=data, headers=headers)
+        return self.session.patch(
+            self.join_url(url),
+            json=json,
+            data=data,
+            headers=headers,
+            timeout=self._MAX_REQUEST_TIMEOUT_SECONDS,
+        )
 
     @measure_time
     def batch_requests(
@@ -170,10 +218,11 @@ class Http:
         ordering as the requests.
         """
         if timeout is None:
-            timeout = self._MAX_WORKER_TIMEOUT_SECONDS
-        elif timeout < 1 or timeout > self._MAX_WORKER_TIMEOUT_SECONDS:
+            timeout = self._MAX_REQUEST_TIMEOUT_SECONDS
+        elif timeout < 1 or timeout > self._MAX_REQUEST_TIMEOUT_SECONDS:
             raise ValueError(
-                f"Timeout value must be greater than 0 and less than or equal to {self._MAX_WORKER_TIMEOUT_SECONDS} seconds"
+                "Timeout value must be greater than 0 and less than or equal "
+                f"to {self._MAX_REQUEST_TIMEOUT_SECONDS} seconds"
             )
 
         with ThreadPoolExecutor() as executor:
@@ -182,3 +231,42 @@ class Http:
             concurrent.futures.wait(futures, timeout=timeout)
 
             return [future.result() for future in futures]
+
+
+class OntologiesHttp(Http):
+    """
+    An HTTP client for the ontologies service.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(base_url="https://ontologies.canvasmedical.com")
+
+        # import here to avoid making it exportable to module importers
+        import os
+
+        self.session.headers.update({"Authorization": os.getenv("PRE_SHARED_KEY", "")})
+
+
+class ScienceHttp(Http):
+    """
+    An HTTP client for the ontologies service.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(base_url="https://science.canvasmedical.com")
+
+        # import here to avoid making it exportable to module importers
+        import os
+
+        self.session.headers.update({"Authorization": os.getenv("PRE_SHARED_KEY", "")})
+
+
+__all__ = [
+    "Http",
+    "OntologiesHttp",
+    "ScienceHttp",
+    "batch_get",
+    "batch_post",
+    "batch_put",
+    "batch_patch",
+]

canvas_sdk/utils/tests.py

@@ -9,7 +9,9 @@ def test_http_get(mock_get: MagicMock) -> None:
     http = Http()
     http.get("https://www.canvasmedical.com/", headers={"Authorization": "Bearer as;ldkfjdkj"})
     mock_get.assert_called_once_with(
-        "https://www.canvasmedical.com/", headers={"Authorization": "Bearer as;ldkfjdkj"}
+        "https://www.canvasmedical.com/",
+        headers={"Authorization": "Bearer as;ldkfjdkj"},
+        timeout=30,
     )
 
 
@@ -28,6 +30,7 @@ def test_http_post(mock_post: MagicMock) -> None:
         json={"hey": "hi"},
         data="grant-type=client_credentials",
         headers={"Content-type": "application/json"},
+        timeout=30,
     )
 
 
@@ -46,6 +49,7 @@ def test_http_put(mock_put: MagicMock) -> None:
         json={"hey": "hi"},
         data="grant-type=client_credentials",
         headers={"Content-type": "application/json"},
+        timeout=30,
     )
 
 
@@ -64,4 +68,5 @@ def test_http_patch(mock_patch: MagicMock) -> None:
         json={"hey": "hi"},
         data="grant-type=client_credentials",
         headers={"Content-type": "application/json"},
+        timeout=30,
     )

canvas_sdk/v1/data/__init__.py

@@ -1,6 +1,7 @@
 from .allergy_intolerance import AllergyIntolerance, AllergyIntoleranceCoding
 from .appointment import Appointment, AppointmentExternalIdentifier
 from .assessment import Assessment
+from .banner_alert import BannerAlert
 from .billing import BillingLineItem, BillingLineItemModifier
 from .care_team import CareTeamMembership, CareTeamRole
 from .command import Command
@@ -59,6 +60,7 @@ __all__ = [
     "AllergyIntolerance",
     "AllergyIntoleranceCoding",
     "Assessment",
+    "BannerAlert",
     "BillingLineItem",
     "BillingLineItemModifier",
     "CanvasUser",

canvas_sdk/v1/data/banner_alert.py

@@ -0,0 +1,27 @@
+from django.contrib.postgres.fields import ArrayField
+from django.db import models
+
+
+class BannerAlert(models.Model):
+    """BannerAlert."""
+
+    class Meta:
+        managed = False
+        db_table = "canvas_sdk_data_api_banneralert_001"
+
+    dbid = models.BigIntegerField(db_column="dbid", primary_key=True)
+    created = models.DateTimeField()
+    modified = models.DateTimeField()
+    patient = models.ForeignKey(
+        "v1.Patient",
+        on_delete=models.DO_NOTHING,
+        related_name="banner_alerts",
+        null=True,
+    )
+    plugin_name = models.CharField()
+    key = models.CharField()
+    narrative = models.CharField()
+    placement = ArrayField(models.CharField())
+    intent = models.CharField()
+    href = models.CharField()
+    status = models.CharField()

canvas_sdk/v1/data/lab.py

@@ -10,6 +10,7 @@ from canvas_sdk.v1.data.base import (
     TimeframeLookupQuerySetMixin,
     ValueSetLookupQuerySet,
 )
+from canvas_sdk.v1.data.staff import Staff
 
 
 class LabReportQuerySet(BaseQuerySet, CommittableQuerySetMixin, ForPatientQuerySetMixin):
@@ -213,8 +214,7 @@ class LabOrder(models.Model):
     courtesy_copy_type = models.CharField(choices=CourtesyCopyType, null=True)
     courtesy_copy_number = models.CharField()
     courtesy_copy_text = models.CharField()
-    # TODO - uncomment when Staff model is added
-    # ordering_provider = models.ForeignKey(Staff, on_delete=models.DO_NOTHING, null=True)
+    ordering_provider = models.ForeignKey(Staff, on_delete=models.DO_NOTHING, null=True)
     parent_order = models.ForeignKey("LabOrder", on_delete=models.DO_NOTHING, null=True)
     healthgorilla_id = models.CharField()
     manual_processing_status = models.CharField(choices=ManualProcessingStatus)

canvas_sdk/v1/data/staff.py

@@ -46,10 +46,9 @@ class Staff(models.Model):
     cultural_ethnicity_terms = ArrayField(models.CharField())
     last_known_timezone = TimeZoneField(null=True)
     active = models.BooleanField()
-    # TODO - uncomment when PracticeLocation field is developed
-    # primary_practice_location = models.ForeignKey(
-    #     'v1.PracticeLocation', on_delete=models.DO_NOTHING, null=True
-    # )
+    primary_practice_location = models.ForeignKey(
+        "v1.PracticeLocation", on_delete=models.DO_NOTHING, null=True
+    )
     npi_number = models.CharField()
     nadean_number = models.CharField()
     group_npi_number = models.CharField()

plugin_runner/authentication.py

@@ -25,7 +25,8 @@ def token_for_plugin(
 
     if not jwt_signing_key:
         log.warning(
-            "Using an insecure JWT signing key for GraphQL access. Set the PLUGIN_RUNNER_SIGNING_KEY environment variable to avoid this message."
+            "Using an insecure JWT signing key for GraphQL access. Set the "
+            "PLUGIN_RUNNER_SIGNING_KEY environment variable to avoid this message."
         )
 
     token = encode(