wbcore 1.46.0__py2.py3-none-any.whl → 1.58.2__py2.py3-none-any.whl

wbcore/contrib/workflow/tests/test_workflow_assignees.py

@@ -1,10 +1,9 @@
-from unittest.mock import patch
-
 import pytest
+from pytest_mock import MockerFixture
 
-from wbcore.contrib.authentication.factories import GroupFactory, UserFactory
-from wbcore.contrib.directory.factories import ClientFactory
-from wbcore.contrib.workflow.models import ProcessStep, Step
+from wbcore.contrib.authentication.models import Group, User
+from wbcore.contrib.directory.models import Entry
+from wbcore.contrib.workflow.models import Process, ProcessStep, Step
 from wbcore.contrib.workflow.workflows import (
     manager_of_instance_assignee,
     random_group_member,
@@ -12,215 +11,226 @@ from wbcore.contrib.workflow.workflows import (
 )
 
 
-@pytest.mark.django_db
 class TestWorkflowAssignees:
-    def test_manager_of_instance_assignee_person(self, process_step_factory):
-        kwargs = {"assignee_field": "profile", "assignee_type": "entry"}
-        attached_instance = UserFactory()
-        process_step = process_step_factory(process__instance=attached_instance)
-        manager_list = ClientFactory.create_batch(3, clients=[attached_instance.profile])
-        UserFactory(profile=manager_list[1], is_active=False)
-        UserFactory(profile=manager_list[2])
-        assert manager_of_instance_assignee(process_step, **kwargs) == manager_list[2].user_account
-
-    def test_manager_of_instance_assignee_no_kwargs(self, process_step_factory):
-        process_step = process_step_factory()
-        assert not manager_of_instance_assignee(process_step)
-        assert process_step.state == ProcessStep.StepState.FAILED
-
-    def test_manager_of_instance_assignee_no_assignee_field(self, process_step_factory):
-        kwargs = {"test": "profile", "assignee_type": "entry"}
-        process_step = process_step_factory()
-        assert not manager_of_instance_assignee(process_step, **kwargs)
-        assert process_step.state == ProcessStep.StepState.FAILED
+    @pytest.fixture
+    def mocked_active_user(self, mocker: MockerFixture):
+        return mocker.MagicMock(spec=User, is_active=True)
 
-    def test_manager_of_instance_assignee_no_assignee_type(self, process_step_factory):
-        kwargs = {"assignee_field": "profile", "test": "entry"}
-        process_step = process_step_factory()
-        assert not manager_of_instance_assignee(process_step, **kwargs)
-        assert process_step.state == ProcessStep.StepState.FAILED
+    @pytest.fixture
+    def mocked_group(self, mocker: MockerFixture):
+        return mocker.MagicMock(spec=Group)
 
-    def test_manager_of_instance_assignee_wrong_assignee_field(self, process_step_factory):
+    def test_manager_of_instance_assignee_person(self, mocker: MockerFixture, mocked_process_step, mocked_active_user):
+        # Arrange
         kwargs = {"assignee_field": "profile", "assignee_type": "entry"}
-        process_step = process_step_factory()
-        assert not manager_of_instance_assignee(process_step, **kwargs)
-        assert process_step.state == ProcessStep.StepState.FAILED
 
-    def test_manager_of_instance_assignee_wrong_assignee_type(self, process_step_factory):
-        kwargs = {"assignee_field": "profile", "assignee_type": "test"}
-        attached_instance = UserFactory()
-        process_step = process_step_factory(process__instance=attached_instance)
-        assert not manager_of_instance_assignee(process_step, **kwargs)
-        assert process_step.state == ProcessStep.StepState.FAILED
-
-    @pytest.mark.parametrize(
-        "bad_states", [ProcessStep.StepState.FAILED, ProcessStep.StepState.CANCELED, ProcessStep.StepState.WAITING]
-    )
-    @pytest.mark.parametrize(
-        "bad_types",
-        [
-            Step.StepType.DECISIONSTEP,
-            Step.StepType.EMAILSTEP,
-            Step.StepType.FINISHSTEP,
-            Step.StepType.JOINSTEP,
-            Step.StepType.SPLITSTEP,
-            Step.StepType.SCRIPTSTEP,
-        ],
-    )
-    @patch("wbcore.contrib.workflow.workflows.assignees.choices")
-    def test_weighted_random(self, mock_choices, user_step_factory, process_step_factory, bad_states, bad_types):
-        group = GroupFactory()
-        process_step = process_step_factory(group=group)
-        assignee1 = UserFactory(groups=[group])
-        assignee2 = UserFactory(groups=[group])
-        user_step = user_step_factory()
-        process_step_factory(
-            state=ProcessStep.StepState.ACTIVE,
-            process=process_step.process,
-            group=process_step.group,
-            step=user_step,
-            assignee=assignee1,
-        )
-        process_step_factory(
-            state=ProcessStep.StepState.FINISHED,
-            process=process_step.process,
-            group=process_step.group,
-            step=user_step,
-            assignee=assignee2,
-        )
-        process_step_factory(
-            state=ProcessStep.StepState.FINISHED,
-            process=process_step.process,
-            group=process_step.group,
-            step=user_step,
-            assignee=assignee2,
-        )
-        process_step_factory(
-            state=bad_states,
-            process=process_step.process,
-            group=process_step.group,
-            step=user_step,
-            assignee=assignee2,
-        )
-        process_step_factory(
-            state=ProcessStep.StepState.ACTIVE,
-            group=process_step.group,
-            step=user_step,
-            assignee=assignee2,
-        )
-        process_step_factory(
-            state=ProcessStep.StepState.ACTIVE,
-            process=process_step.process,
-            step=user_step,
-            assignee=assignee2,
-        )
-        process_step_factory(
-            state=ProcessStep.StepState.FINISHED,
-            process=process_step.process,
-            group=process_step.group,
-            step__step_type=bad_types,
-            assignee=assignee2,
+        user_a = mocker.MagicMock(spec=User, is_active=False)
+        manager_a = mocker.MagicMock(spec=Entry, user_account=user_a)
+        manager_b = mocker.MagicMock(spec=Entry, user_account=mocked_active_user)
+
+        assignee_mock = mocker.MagicMock()
+
+        mocked_process_step.process.instance = mocker.MagicMock(spec=User)
+        mocked_process_step.process.instance.profile = assignee_mock
+
+        assignee_mock.relationship_managers.all.return_value = [manager_a, manager_b]
+        # Act
+        result = manager_of_instance_assignee(mocked_process_step, **kwargs)
+        # Assert
+        assert result == manager_b.user_account
+
+    def test_manager_of_instance_assignee_no_kwargs(self, mocked_process_step, mocker: MockerFixture):
+        mocked_process_step.step.get_casted_step.return_value = mocker.MagicMock(spec=Step)
+        result = manager_of_instance_assignee(mocked_process_step)
+        assert result is None
+        mocked_process_step.step.get_casted_step().set_failed.assert_called_once_with(
+            mocked_process_step,
+            "Error in assignee method: Incorrect input in kwargs field!",
         )
-        process_step_factory(
-            state=ProcessStep.StepState.FINISHED,
-            process=process_step.process,
-            group=process_step.group,
-            step=user_step,
+
+    def test_manager_of_instance_assignee_no_assignee_field(self, mocked_process_step):
+        kwargs = {"test": "profile", "assignee_type": "entry"}
+        result = manager_of_instance_assignee(mocked_process_step, **kwargs)
+        assert result is None
+        mocked_process_step.step.get_casted_step().set_failed.assert_called_once_with(
+            mocked_process_step,
+            "Error in assignee method: Incorrect input in kwargs field!",
         )
-        assert weighted_random(process_step)
-        assert len(mock_choices.call_args.args) == 1
-        assert len(mock_choices.call_args.kwargs) == 1
-        assignees_with_weights = set(zip(mock_choices.call_args.args[0], mock_choices.call_args.kwargs["weights"]))
-        assert assignees_with_weights == {(assignee1, 2 / 3), (assignee2, 1 / 3)}
-
-    @pytest.mark.parametrize(
-        "bad_states", [ProcessStep.StepState.FAILED, ProcessStep.StepState.CANCELED, ProcessStep.StepState.WAITING]
-    )
-    @pytest.mark.parametrize(
-        "bad_types",
-        [
-            Step.StepType.DECISIONSTEP,
-            Step.StepType.EMAILSTEP,
-            Step.StepType.FINISHSTEP,
-            Step.StepType.JOINSTEP,
-            Step.StepType.SPLITSTEP,
-            Step.StepType.SCRIPTSTEP,
-        ],
-    )
-    @patch("wbcore.contrib.workflow.workflows.assignees.choices")
-    def test_weighted_random_no_past_ocurrences(
-        self, mock_choices, user_step_factory, process_step_factory, bad_states, bad_types
-    ):
-        group = GroupFactory()
-        process_step = process_step_factory(group=group)
-        assignee1 = UserFactory(groups=[group])
-        assignee2 = UserFactory(groups=[group])
-        user_step = user_step_factory()
-
-        process_step_factory(
-            state=bad_states,
-            process=process_step.process,
-            group=process_step.group,
-            step=user_step,
-            assignee=assignee2,
+
+    def test_manager_of_instance_assignee_no_assignee_type(self, mocked_process_step):
+        kwargs = {"assignee_field": "profile", "test": "entry"}
+        result = manager_of_instance_assignee(mocked_process_step, **kwargs)
+        assert result is None
+        mocked_process_step.step.get_casted_step().set_failed.assert_called_once_with(
+            mocked_process_step,
+            "Error in assignee method: Incorrect input in kwargs field!",
         )
-        process_step_factory(
-            state=ProcessStep.StepState.ACTIVE,
-            group=process_step.group,
-            step=user_step,
-            assignee=assignee2,
+
+    def test_manager_of_instance_assignee_wrong_assignee_field(self, mocked_process_step):
+        kwargs = {"assignee_field": "profile", "assignee_type": "entry"}
+        result = manager_of_instance_assignee(mocked_process_step, **kwargs)
+        assert result is None
+        mocked_process_step.step.get_casted_step().set_failed.assert_called_once_with(
+            mocked_process_step,
+            "Error in assignee method: Incorrect input in kwargs field!",
         )
-        process_step_factory(
-            state=ProcessStep.StepState.ACTIVE,
-            process=process_step.process,
-            step=user_step,
-            assignee=assignee2,
+
+    def test_manager_of_instance_assignee_wrong_assignee_type(self, mocked_process_step, mocked_active_user):
+        kwargs = {"assignee_field": "profile", "assignee_type": "test"}
+        mocked_process_step.process.instance = mocked_active_user
+        result = manager_of_instance_assignee(mocked_process_step, **kwargs)
+        assert result is None
+        mocked_process_step.step.get_casted_step().set_failed.assert_called_once_with(
+            mocked_process_step,
+            "Error in assignee method: Incorrect input in kwargs field!",
         )
-        process_step_factory(
-            state=ProcessStep.StepState.FINISHED,
-            process=process_step.process,
-            group=process_step.group,
-            step__step_type=bad_types,
-            assignee=assignee2,
+
+    def test_weighted_random_with_prior_assignments(self, mocker: MockerFixture, mocked_process_step, mocked_group):
+        # Arrange
+        user_a = mocker.MagicMock(spec=User, pk=1)
+        user_b = mocker.MagicMock(spec=User, pk=2)
+        mock_group_users = [user_a, user_b]
+
+        mocked_group.user_set.all.return_value = mock_group_users
+        mocked_group.user_set.count.return_value = len(mock_group_users)
+
+        mocked_process_step.group = mocked_group
+        mocked_process_step.process = mocker.MagicMock(spec=Process)
+
+        mocked_choices = mocker.patch("wbcore.contrib.workflow.workflows.assignees.choices", return_value=[user_a])
+        mocked_qs = mocker.patch("wbcore.contrib.workflow.workflows.assignees.ProcessStep.objects.filter")
+
+        mocked_query = mocked_qs.return_value
+        mocked_query.exclude.return_value.values_list.return_value = [1, 2, 2]
+        # Act
+        result = weighted_random(mocked_process_step)
+
+        mocked_choices.assert_called_once_with(mock_group_users, weights=mocker.ANY)
+        assignees, weights = (
+            mocked_choices.call_args.args[0],
+            mocked_choices.call_args.kwargs["weights"],
         )
-        process_step_factory(
-            state=ProcessStep.StepState.FINISHED,
-            process=process_step.process,
-            group=process_step.group,
-            step=user_step,
+        # Assert
+        assert assignees == mock_group_users
+        assert weights == pytest.approx([2 / 3, 1 / 3], rel=1e-2)
+        assert result in mock_group_users
+
+    def test_weighted_random_no_group(self, mocker: MockerFixture, mocked_process_step):
+        # Arrange
+        mocked_process_step.group = None
+        mocked_failed_method = mocker.patch.object(mocked_process_step.step.get_casted_step(), "set_failed")
+        # Act
+        result = weighted_random(mocked_process_step)
+        # Assert
+        mocked_failed_method.assert_called_once()
+        assert result is None
+
+    def test_weighted_random_empty_group(self, mocker: MockerFixture, mocked_process_step, mocked_group):
+        # Arrange
+        mocked_group.user_set.count.return_value = 0
+        mocked_process_step.group = mocked_group
+        mocked_fail_method = mocker.patch.object(mocked_process_step.step.get_casted_step(), "set_failed")
+        # Act
+        result = weighted_random(mocked_process_step)
+        # Assert
+        mocked_fail_method.assert_called_once()
+        assert result is None
+
+    def test_weighted_random_no_prior_assignments(self, mocker: MockerFixture, mocked_process_step, mocked_group):
+        # Arrange
+        user_a = mocker.MagicMock(spec=User, pk=1)
+        user_b = mocker.MagicMock(spec=User, pk=2)
+
+        mock_group_users = [user_a, user_b]
+        mocked_group.user_set.all.return_value = mock_group_users = [user_a, user_b]
+        mocked_group.user_set.count.return_value = 2
+        mocked_process_step.group = mocked_group
+
+        mocked_choices = mocker.patch(
+            "wbcore.contrib.workflow.workflows.assignees.choices",
+            return_value=[user_b],
         )
-        assert weighted_random(process_step)
-        assert len(mock_choices.call_args.args) == 1
-        assert set(mock_choices.call_args.args[0]) == {assignee1, assignee2}
-        assert not mock_choices.call_args.kwargs
-
-    @patch("wbcore.contrib.workflow.workflows.assignees.choices")
-    def test_weighted_random_no_group(self, mock_choices, process_step_factory):
-        process_step = process_step_factory()
-        assert not weighted_random(process_step)
-        assert not mock_choices.called
-        assert process_step.state == ProcessStep.StepState.FAILED
-
-    @patch("wbcore.contrib.workflow.workflows.assignees.choices")
-    def test_weighted_random_no_group_members(self, mock_choices, process_step_factory):
-        process_step = process_step_factory(group=GroupFactory())
-        assert not weighted_random(process_step)
-        assert not mock_choices.called
-        assert process_step.state == ProcessStep.StepState.FAILED
-
-    def test_random_group_member(self, process_step_factory):
-        group = GroupFactory()
-        process_step = process_step_factory(group=group)
-        UserFactory(groups=[group])
-        UserFactory(groups=[group])
-        assert random_group_member(process_step)
-
-    def test_random_group_member_no_group(self, process_step_factory):
-        process_step = process_step_factory()
-        assert not random_group_member(process_step)
-        assert process_step.state == ProcessStep.StepState.FAILED
-
-    def test_random_group_member_no_group_members(self, process_step_factory):
-        process_step = process_step_factory(group=GroupFactory())
-        assert not random_group_member(process_step)
-        assert process_step.state == ProcessStep.StepState.FAILED
+        mocked_qs = mocker.patch("wbcore.contrib.workflow.workflows.assignees.ProcessStep.objects.filter")
+        mocked_query = mocked_qs.return_value
+        mocked_query.exclude.return_value.values_list.return_value = []
+        # Act
+        result = weighted_random(mocked_process_step)
+        # Assert
+        mocked_choices.assert_called_once_with(mock_group_users)
+        assert result == user_b
+
+    def test_weighted_random_single_user(self, mocker: MockerFixture, mocked_process_step, mocked_group):
+        # Arrange
+        user_a = mocker.MagicMock(spec=User, pk=1)
+        mocked_group.user_set.all.return_value = [user_a]
+        mocked_group.user_set.count.return_value = 1
+        mocked_process_step.group = mocked_group
+        mocked_process_step.process = mocker.MagicMock(spec=Process)
+
+        mocked_qs = mocker.patch("wbcore.contrib.workflow.workflows.assignees.ProcessStep.objects.filter")
+
+        mocked_query = mocked_qs.return_value
+        mocked_query.exclude.return_value.values_list.return_value = []
+        # Act
+        result = weighted_random(mocked_process_step)
+        # Assert
+        assert result == user_a
+
+    def test_random_group_member_multiple_users(self, mocker: MockerFixture, mocked_process_step, mocked_group):
+        # Arrange
+        mocked_process_step = mocker.MagicMock(spec=ProcessStep)
+
+        user_a = mocker.MagicMock(spec=User)
+        user_b = mocker.MagicMock(spec=User)
+        user_c = mocker.MagicMock(spec=User)
+        users = [user_a, user_b, user_c]
+
+        mocked_group.user_set.exists.return_value = True
+        mocked_group.user_set.count.return_value = 3
+        mocked_group.user_set.all.return_value = users
+
+        mocked_process_step.group = mocked_group
+
+        mock_randint = mocker.patch("wbcore.contrib.workflow.workflows.assignees.randint", return_value=1)
+        # Act
+        result = random_group_member(mocked_process_step)
+        # Assert
+        mock_randint.assert_called_once_with(0, 2)
+        assert result == user_b  # index 1
+
+    def test_random_group_member_single_user(self, mocker: MockerFixture, mocked_process_step, mocked_group):
+        # Arrange
+        mocked_process_step = mocker.MagicMock(spec=ProcessStep)
+
+        user_a = mocker.MagicMock(spec=User)
+        mocked_group.user_set.exists.return_value = True
+        mocked_group.user_set.count.return_value = 1
+        mocked_group.user_set.all.return_value = [user_a]
+
+        mocked_process_step.group = mocked_group
+        # Act
+        result = random_group_member(mocked_process_step)
+        # Assert
+        assert result == user_a
+
+    def test_random_group_member_empty_group(self, mocker, mocked_process_step, mocked_group):
+        # Arrange
+        mocked_process_step.group = mocked_group
+        mocked_process_step.group.user_set.exists.return_value = False
+
+        mocked_set_failed = mocker.patch.object(mocked_process_step.step.get_casted_step(), "set_failed")
+        # Act
+        result = random_group_member(mocked_process_step)
+        # Assert
+        mocked_set_failed.assert_called_once()
+        assert result is None
+
+    def test_random_group_member_no_group(self, mocker, mocked_process_step):
+        # Arrange
+        mocked_process_step.group = None
+        mocked_set_failed = mocker.patch.object(mocked_process_step.step.get_casted_step(), "set_failed")
+        # Act
+        result = random_group_member(mocked_process_step)
+        # Assert
+        mocked_set_failed.assert_called_once()
+        assert result is None

wbcore/contrib/workflow/viewsets/process.py

@@ -164,7 +164,10 @@ class AssignedProcessStepModelViewSet(ProcessStepModelViewSet):
                     )
                 )
             )
-            .annotate(attached_model=F("step__workflow__model__model"), workflow_name=F("step__workflow__name"))
+            .annotate(
+                attached_model=F("step__workflow__model__model"),
+                workflow_name=F("step__workflow__name"),
+            )
         ).select_related("step__workflow")
         return qs
 

wbcore/contrib/workflow/workflows/assignees.py

@@ -38,7 +38,10 @@ def weighted_random(process_step: ProcessStep, **kwargs) -> User | None:
     if (group := process_step.group) and (group_user_count := group.user_set.count()):
         similar_process_steps_selected_assignees: list[str] = list(
             ProcessStep.objects.filter(
-                state__in=[ProcessStep.StepState.FINISHED, ProcessStep.StepState.ACTIVE],
+                state__in=[
+                    ProcessStep.StepState.FINISHED,
+                    ProcessStep.StepState.ACTIVE,
+                ],
                 process=process_step.process,
                 group=group,
                 assignee__isnull=False,
@@ -56,18 +59,19 @@ def weighted_random(process_step: ProcessStep, **kwargs) -> User | None:
             # We redistribute each occurrence number between all of the other list items to increase their probability
             redistributed_list: list[int] = [0 for i in range(group_user_count)]
             for index, elem in enumerate(number_of_past_assignee_occurrences):
-                for index2, elem2 in enumerate(redistributed_list):
+                for index2 in range(len(redistributed_list)):
                     if not index2 == index:
                         redistributed_list[index2] += elem / (group_user_count - 1) if elem else 0
             # Transform the list of absolute values into percentages
             new_weights: list[float] = [x / sum(redistributed_list) for x in redistributed_list]
-            new_assignee: User = choices(group_member_list, weights=new_weights)[0]
+            new_assignee: User = choices(group_member_list, weights=new_weights)[0]  # noqa
         else:
-            new_assignee: User = choices(group_member_list)[0]
+            new_assignee: User = choices(group_member_list)[0]  # noqa
         return new_assignee
 
     process_step.step.get_casted_step().set_failed(
-        process_step, _("Error in assignee method: No populated group to pick assignee from selected!")
+        process_step,
+        _("Error in assignee method: No populated group to pick assignee from selected!"),
     )
     return None
 
@@ -75,9 +79,10 @@ def weighted_random(process_step: ProcessStep, **kwargs) -> User | None:
 @register_assignee("Random Group Member")
 def random_group_member(process_step: ProcessStep, **kwargs) -> User | None:
     if (group := process_step.group) and group.user_set.exists():
-        return group.user_set.all()[randint(0, group.user_set.count() - 1)]
+        return group.user_set.all()[randint(0, group.user_set.count() - 1)]  # noqa
 
     process_step.step.get_casted_step().set_failed(
-        process_step, _("Error in assignee method: No populated group to pick assignee from selected!")
+        process_step,
+        _("Error in assignee method: No populated group to pick assignee from selected!"),
     )
     return None

wbcore/dynamic_preferences_registry.py

@@ -2,6 +2,10 @@ from django.utils.translation import gettext as _
 from dynamic_preferences.preferences import Section
 from dynamic_preferences.registries import global_preferences_registry
 from dynamic_preferences.types import IntegerPreference, StringPreference
+from dynamic_preferences.users.registries import user_preferences_registry
+
+from wbcore.contrib.dynamic_preferences.types import ChoicePreference, LanguageChoicePreference
+from wbcore.utils.date import get_timezone_choices
 
 wbcore = Section("wbcore")
 
@@ -27,3 +31,101 @@ class SystemUserEmailPeriod(StringPreference):
 
     verbose_name = _("System User Email")
     help_text = _("System User Email")
+
+
+@user_preferences_registry.register
+class LanguagePreference(LanguageChoicePreference):
+    weight = -1
+    choices = [
+        ("de", "Deutsch"),
+        ("fr", "Français"),
+        ("en", "English"),
+    ]
+
+    section = wbcore
+    name = "language"
+    default = "en"
+
+    verbose_name = _("System Language")
+    help_text = _("Select the language you want the Workbench to display.")
+
+
+@user_preferences_registry.register
+class TimezonePreference(ChoicePreference):
+    weight = 0
+    # Value is a IANA timezone name
+    choices = get_timezone_choices()
+    section = wbcore
+    name = "timezone"
+    default = "Europe/Berlin"
+
+    verbose_name = _("Timezone")
+    help_text = _("Pick the timezone in which you want the workbench's dates to be displayed in.")
+
+
+@user_preferences_registry.register
+class DateFormatPreference(ChoicePreference):
+    weight = 1
+    choices = [
+        ("DD.MM.YYYY", "13.04.2007"),
+        ("DD/MM/YYYY", "13/04/2007"),
+        ("DD-MM-YYYY", "13-04-2007"),
+        ("MM/DD/YYYY", "04/13/2007"),
+        ("MM-DD-YYYY", "04-13-2007"),
+        ("YYYY/MM/DD", "2007/04/13"),
+        ("YYYY-MM-DD", "2007-04-13"),
+        ("MMM DD, YYYY", "April 13, 2007"),
+        ("DD MMM YYYY", "13 April 2007"),
+        ("dddd, DD MMM YYYY", "Friday, 13 April 2007"),
+        ("ddd, DD MMM YYYY", "Fri, 13 April 2007"),
+        ("ddd Do MMMM YYYY", "Fri 13th April 2007"),
+    ]
+
+    section = wbcore
+    name = "date_format"
+    default = "YYYY-MM-DD"
+
+    verbose_name = _("Date Format")
+    help_text = _("Choose how you want dates to appear throughout the Workbench.")
+
+
+@user_preferences_registry.register
+class TimeFormatPreference(ChoicePreference):
+    weight = 2
+    choices = [
+        ("HH:mm", "14:05"),
+        ("hh:mm", "02:05"),
+        ("h:mm", "2:05"),
+        ("HH [h] mm", "14 h 05"),
+        ("HH[h]mm", "14h05"),
+        ("h:mm A", "2:05 PM"),
+        ("h:mm a", "2:05 pm"),
+        ("hh:mm A", "02:05 PM"),
+        ("hh:mm a", "02:05 pm"),
+    ]
+
+    section = wbcore
+    name = "time_format"
+    default = "HH:mm"
+
+    verbose_name = _("Time Format")
+    help_text = _("Choose how you want times to appear throughout the Workbench.")
+
+
+@user_preferences_registry.register
+class NumberFormatPreference(ChoicePreference):
+    weight = 3
+    # Value is a BCP 47 region subtag
+    choices = [
+        ("US", "1,234,567.89"),
+        ("FR", "1\u202f234\u202f567,89"),
+        ("DE", "1.234.567,89"),
+        ("CH", "1’234’567.89"),
+    ]
+
+    section = wbcore
+    name = "number_format"
+    default = "US"
+
+    verbose_name = _("Number Format")
+    help_text = _("Choose how you want numbers to appear throughout the Workbench.")