From ea3315c937b960fc49e3effbb7497e29f5fa2442 Mon Sep 17 00:00:00 2001
From: wachi <wasudd@gmail.com>
Date: Mon, 19 Oct 2026 12:37:20 +0700
Subject: [PATCH 1/7] [FIX] ni_period: compute the start date from period_start
 on create

period_start_date is a stored computed field with a default of today. On
create, a default counts as a given value, so the compute never runs: records
created from code (import, RPC, bulk wizards) with only period_start got today
as their start date, and an encounter could then fail the end-date check when
it was closed.

Drop the default. period_start already defaults to now, so a new record in the
form still starts today.

Existing databases still hold the wrong dates, so the version bump ships an
end-migration script that repairs them. It runs at end- time because ni_period
has no dependencies, and goes through every stored model on the mixin, skipping
SQL views and models that declare their own period_start_date (ni.condition
already had default=None). It only fixes datetime-mode rows whose start date
differs from period_start and equals their creation day (+/- 1 day for the
creating user's timezone); date-mode rows are left alone, since there a
mismatch can be intended. Each row gets period_start::date, as the compute
does, and the number of fixed rows is logged per model.

The tests use a fake model on the mixin: the create case, and the script on a
fixed row, a date-mode row, a correct row and a model with its own field.

Production must run `-u ni_period` on 16.0 with this version before the
OpenUpgrade 16 -> 17 step: OCA keeps only the current version's scripts.

Refs: nirun-life/nirun#135
---
 ni_period/__manifest__.py                     |   2 +-
 .../migrations/16.0.0.1.1/end-migration.py    |  68 ++++++++++++
 ni_period/models/ni_period_mixin.py           |   1 -
 ni_period/tests/__init__.py                   |   3 +
 ni_period/tests/models.py                     |  23 ++++
 ni_period/tests/test_ni_period_start_date.py  | 103 ++++++++++++++++++
 6 files changed, 198 insertions(+), 2 deletions(-)
 create mode 100644 ni_period/migrations/16.0.0.1.1/end-migration.py
 create mode 100644 ni_period/tests/__init__.py
 create mode 100644 ni_period/tests/models.py
 create mode 100644 ni_period/tests/test_ni_period_start_date.py

diff --git a/ni_period/__manifest__.py b/ni_period/__manifest__.py
index d57ebb4e4..203c926f4 100644
--- a/ni_period/__manifest__.py
+++ b/ni_period/__manifest__.py
@@ -3,7 +3,7 @@
 {
     "name": "Nirun - Period",
     "summary": "Time period fields (start/end datetime ranges) for clinical resources",
-    "version": "16.0.0.1.0",
+    "version": "16.0.0.1.1",
     "development_status": "Alpha",
     "category": "Medical",
     "author": "NSTDA, Piruin P.",
diff --git a/ni_period/migrations/16.0.0.1.1/end-migration.py b/ni_period/migrations/16.0.0.1.1/end-migration.py
new file mode 100644
index 000000000..ef0593120
--- /dev/null
+++ b/ni_period/migrations/16.0.0.1.1/end-migration.py
@@ -0,0 +1,68 @@
+#  Copyright (c) 2026 NSTDA
+"""Repair the start dates written by the old ``period_start_date`` default.
+
+Up to 16.0.0.1.0, ``period_start_date`` defaulted to today. On create a default
+counts as a given value, so the compute never ran: every record created from
+code (import, RPC, bulk wizards) stored its creation day instead of the date of
+its ``period_start``.
+
+This runs as an ``end-`` script because ``ni_period`` has no dependencies: at
+``post-`` time none of the models that use the mixin are loaded yet.
+"""
+import logging
+
+from odoo import SUPERUSER_ID, api
+
+_logger = logging.getLogger(__name__)
+
+MIXIN = "ni.period.mixin"
+
+
+def _defines_own_start_date(model):
+    """True when the model (or an extension of it) declares its own
+    ``period_start_date``; ``ni.condition`` did, with ``default=None``, so the
+    bug never reached it."""
+    for cls in type(model).mro()[1:]:
+        if "period_start_date" in vars(cls) and getattr(cls, "_name", None) != MIXIN:
+            return True
+    return False
+
+
+def _models_to_fix(env):
+    for model_name in sorted(env.registry.descendants([MIXIN], "_inherit")):
+        model = env[model_name]
+        if model._abstract or not model._auto or _defines_own_start_date(model):
+            continue
+        yield model
+
+
+def fix_period_start_date(env):
+    for model in _models_to_fix(env):
+        # Only datetime-mode rows: in date mode the inverse leaves period_start
+        # alone when the user edits the date, so a mismatch can be intended.
+        # The old default used the creating user's timezone, hence +/- 1 day.
+        env.cr.execute(
+            f"""
+            UPDATE "{model._table}"
+            SET period_start_date = period_start::date
+            WHERE period_mode = 'datetime'
+              AND period_start IS NOT NULL
+              AND period_start_date <> period_start::date
+              AND period_start_date BETWEEN create_date::date - 1
+                                        AND create_date::date + 1
+            """
+        )
+        if env.cr.rowcount:
+            _logger.info(
+                "ni_period: fixed period_start_date on %s %s rows",
+                env.cr.rowcount,
+                model._name,
+            )
+            model.invalidate_model(["period_start_date"])
+
+
+def migrate(cr, version):
+    if not version:
+        return
+    env = api.Environment(cr, SUPERUSER_ID, {})
+    fix_period_start_date(env)
diff --git a/ni_period/models/ni_period_mixin.py b/ni_period/models/ni_period_mixin.py
index 6581511d6..195954ac9 100644
--- a/ni_period/models/ni_period_mixin.py
+++ b/ni_period/models/ni_period_mixin.py
@@ -28,7 +28,6 @@ class PeriodMixin(models.AbstractModel):
         store=True,
         compute="_compute_period_start_date",
         inverse="_inverse_period_start_date",
-        default=lambda self: fields.Date.context_today(self),
     )
     period_end = fields.Datetime(
         "Until",
diff --git a/ni_period/tests/__init__.py b/ni_period/tests/__init__.py
new file mode 100644
index 000000000..e5f4f7b45
--- /dev/null
+++ b/ni_period/tests/__init__.py
@@ -0,0 +1,3 @@
+#  Copyright (c) 2026 NSTDA
+
+from . import test_ni_period_start_date
diff --git a/ni_period/tests/models.py b/ni_period/tests/models.py
new file mode 100644
index 000000000..0c60732f2
--- /dev/null
+++ b/ni_period/tests/models.py
@@ -0,0 +1,23 @@
+#  Copyright (c) 2026 NSTDA
+
+from odoo import fields, models
+
+
+class PeriodTest(models.Model):
+    _name = "ni.period.test"
+    _inherit = "ni.period.mixin"
+    _description = "Period Test"
+
+
+class PeriodOwnDateTest(models.Model):
+    _name = "ni.period.own.date.test"
+    _inherit = "ni.period.mixin"
+    _description = "Period Test (own start date)"
+
+    period_start_date = fields.Date(
+        default=None,
+        compute="_compute_period_start_date",
+        inverse="_inverse_period_start_date",
+        store=True,
+        readonly=False,
+    )
diff --git a/ni_period/tests/test_ni_period_start_date.py b/ni_period/tests/test_ni_period_start_date.py
new file mode 100644
index 000000000..5afd52ec9
--- /dev/null
+++ b/ni_period/tests/test_ni_period_start_date.py
@@ -0,0 +1,103 @@
+#  Copyright (c) 2026 NSTDA
+
+import importlib.util
+from datetime import date, datetime
+from pathlib import Path
+
+from odoo_test_helper import FakeModelLoader
+
+from odoo.tests import TransactionCase
+
+SCRIPT = (
+    Path(__file__).resolve().parents[1]
+    / "migrations"
+    / "16.0.0.1.1"
+    / "end-migration.py"
+)
+
+
+def _load_script():
+    spec = importlib.util.spec_from_file_location("ni_period_end_migration", SCRIPT)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+class TestPeriodStartDate(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.loader = FakeModelLoader(cls.env, cls.__module__)
+        cls.loader.backup_registry()
+        from .models import PeriodOwnDateTest, PeriodTest
+
+        cls.loader.update_registry((PeriodTest, PeriodOwnDateTest))
+        cls.Period = cls.env["ni.period.test"]
+        cls.PeriodOwn = cls.env["ni.period.own.date.test"]
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.loader.restore_registry()
+        super().tearDownClass()
+
+    def _set_start_date_to_creation_day(self, record):
+        """Write what the old default stored: the day the record was created."""
+        self.env.flush_all()
+        self.env.cr.execute(
+            f'UPDATE "{record._table}" SET period_start_date = create_date::date '
+            "WHERE id = %s",
+            (record.id,),
+        )
+        record.invalidate_recordset(["period_start_date"])
+
+    def _start_date(self, record):
+        self.env.flush_all()
+        self.env.cr.execute(
+            f'SELECT period_start_date FROM "{record._table}" WHERE id = %s',
+            (record.id,),
+        )
+        return self.env.cr.fetchone()[0]
+
+    def test_period_start_date_follows_period_start_on_create(self):
+        """Records created from code (import, RPC) get the start date of their
+        period_start, not today."""
+        record = self.Period.create({"period_start": datetime(2025, 3, 1, 3, 0)})
+        self.assertEqual(record.period_start_date, date(2025, 3, 1))
+
+    def test_end_migration_repairs_start_dates(self):
+        start = datetime(2025, 3, 1, 3, 0)
+        wrong = self.Period.create({"period_start": start})
+        self._set_start_date_to_creation_day(wrong)
+        date_mode = self.Period.create({"period_mode": "date", "period_start": start})
+        self._set_start_date_to_creation_day(date_mode)
+        correct = self.Period.create({"period_start": start})
+        own = self.PeriodOwn.create({"period_start": start})
+        self._set_start_date_to_creation_day(own)
+        creation_day = self._start_date(wrong)
+        self.assertNotEqual(creation_day, date(2025, 3, 1))
+
+        with self.assertLogs("ni_period_end_migration", "INFO") as logs:
+            _load_script().migrate(self.env.cr, "16.0.0.1.0")
+
+        # 1. a datetime-mode row holding its creation day is fixed
+        self.assertEqual(self._start_date(wrong), date(2025, 3, 1))
+        self.assertEqual(wrong.period_start_date, date(2025, 3, 1))
+        # 2. a date-mode row with a deliberate mismatch is left alone
+        self.assertEqual(self._start_date(date_mode), creation_day)
+        # 3. a row that is already correct is left alone
+        self.assertEqual(self._start_date(correct), date(2025, 3, 1))
+        # 4. a model that defines its own field is skipped
+        self.assertEqual(self._start_date(own), creation_day)
+        self.assertEqual(
+            logs.output,
+            [
+                "INFO:ni_period_end_migration:ni_period: fixed period_start_date "
+                "on 1 ni.period.test rows"
+            ],
+        )
+
+    def test_end_migration_skips_a_fresh_install(self):
+        wrong = self.Period.create({"period_start": datetime(2025, 3, 1, 3, 0)})
+        self._set_start_date_to_creation_day(wrong)
+        _load_script().migrate(self.env.cr, None)
+        self.assertNotEqual(self._start_date(wrong), date(2025, 3, 1))

From 095d84bd92b40493b4df36f5e9a65e0583f4730b Mon Sep 17 00:00:00 2001
From: wachi <wasudd@gmail.com>
Date: Mon, 19 Oct 2026 12:37:20 +0700
Subject: [PATCH 2/7] [FIX] partner_age: remove a test file that never ran

tests/test_res_partner.py was not imported in tests/__init__.py, so it never
ran. It is a near copy of test_res_partner_age.py (the same cases, two
assertions in a different order), so there is nothing to merge.

Refs: nirun-life/nirun#135
---
 partner_age/tests/test_res_partner.py | 76 ---------------------------
 1 file changed, 76 deletions(-)
 delete mode 100644 partner_age/tests/test_res_partner.py

diff --git a/partner_age/tests/test_res_partner.py b/partner_age/tests/test_res_partner.py
deleted file mode 100644
index d34f2f84c..000000000
--- a/partner_age/tests/test_res_partner.py
+++ /dev/null
@@ -1,76 +0,0 @@
-#  Copyright (c) 2021-2023 NSTDA
-
-from dateutil.relativedelta import relativedelta
-
-from odoo import fields
-from odoo.exceptions import ValidationError
-from odoo.tests import common
-
-
-class TestPartnerAge(common.TransactionCase):
-    def setUp(self):
-        super(TestPartnerAge, self).setUp()
-        self.partners = self.env["res.partner"]
-        self.today = fields.Date.context_today(self.partners)
-
-    def test_age_from_birthdate(self):
-        partner = self.partners.create(
-            {"name": "partner", "birthdate": self.today - relativedelta(years=34)}
-        )
-
-        self.assertEqual(partner.display_age, "34 Years")
-        self.assertEqual(partner.deceased, False)
-
-    def test_age_from_age(self):
-        partner = self.partners.create({"name": "partner", "age": 34})
-
-        self.assertEqual(partner.display_age, "34 Years")
-        self.assertEqual(partner.age_init, 34)
-        self.assertEqual(partner.age_init_date, self.today)
-
-    def test_update_from_age_to_birthdate(self):
-        partner = self.partners.create({"name": "partner", "age": 34})
-
-        partner.update({"birthdate": self.today - relativedelta(years=36)})
-
-        self.assertEqual(partner.display_age, "36 Years")
-        self.assertFalse(partner.age_init)
-        self.assertFalse(partner.age_init_date)
-
-    def test_update_from_birthdate_to_age(self):
-        partner = self.partners.create(
-            {"name": "partner", "birthdate": self.today - relativedelta(years=36)}
-        )
-
-        partner.update({"age": 34})
-
-        self.assertFalse(partner.birthdate)
-
-    def test_deceased(self):
-        partner = self.partners.create(
-            {
-                "name": "partner",
-                "birthdate": self.today - relativedelta(years=62),
-                "deceased_date": self.today - relativedelta(years=2),
-            }
-        )
-
-        self.assertEqual(partner.display_age, "60 Years")
-        self.assertEqual(partner.deceased, True)
-
-    def test_check_deceased(self):
-        with self.assertRaises(ValidationError):
-            self.partners.create(
-                {
-                    "name": "partner",
-                    "birthdate": self.today - relativedelta(years=34),
-                    "deceased_date": self.today - relativedelta(years=47),
-                }
-            )
-        with self.assertRaises(ValidationError):
-            self.partners.create(
-                {
-                    "name": "partner",
-                    "deceased_date": self.today + relativedelta(days=47),
-                }
-            )

From d24c7ccc9cee546ea7ba30e7f8761094732cfb7a Mon Sep 17 00:00:00 2001
From: wachi <wasudd@gmail.com>
Date: Mon, 19 Oct 2026 12:37:20 +0700
Subject: [PATCH 3/7] [FIX] survey_subject: show "Answer Survey" on active
 surveys only

The button's invisible condition compared active with the string 'False',
which never matches a boolean, so the button also showed on archived surveys.
Compare with False.

Refs: nirun-life/nirun#135
---
 survey_subject/__manifest__.py                 | 2 +-
 survey_subject/wizard/survey_subject_views.xml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/survey_subject/__manifest__.py b/survey_subject/__manifest__.py
index 31e9a2a12..67ee7b750 100644
--- a/survey_subject/__manifest__.py
+++ b/survey_subject/__manifest__.py
@@ -3,7 +3,7 @@
 {
     "name": "Survey - Subject",
     "summary": "Survey subjects and respondent management",
-    "version": "16.0.0.3.1",
+    "version": "16.0.0.3.2",
     "development_status": "Alpha",
     "category": "Marketing/Surveys",
     "author": "NSTDA, Piruin P.",
diff --git a/survey_subject/wizard/survey_subject_views.xml b/survey_subject/wizard/survey_subject_views.xml
index 44adc1f57..0229d1637 100644
--- a/survey_subject/wizard/survey_subject_views.xml
+++ b/survey_subject/wizard/survey_subject_views.xml
@@ -126,7 +126,7 @@
                 <button
                     name="action_survey_subject_wizard"
                     string="Answer Survey"
-                    attrs="{'invisible': ['|', '|', ('subject_type', '=', False), ('active', '=', 'False'), ('id', '=', False)]}"
+                    attrs="{'invisible': ['|', '|', ('subject_type', '=', False), ('active', '=', False), ('id', '=', False)]}"
                     class="text-primary"
                     icon="fa-commenting"
                     context="{'default_survey_id': id}"

From 8500f74ecfbbee81efaeec4270381897a38fade1 Mon Sep 17 00:00:00 2001
From: wachi <wasudd@gmail.com>
Date: Mon, 19 Oct 2026 12:37:20 +0700
Subject: [PATCH 4/7] [FIX] ni_observation: compute latest rows one by one,
 valid category ondelete

ni.observation.report._compute_observation browsed self.id inside the loop, so
reading observation_id or the history of several latest rows at once (a list,
an export) raised "Expected singleton". Use rec.id. The test reads two rows of
the patient's latest observations together.

ni.observation.category.parent_id had ondelete="", which is not a valid
value. Set "set null", Odoo's default for a nullable Many2one and what the
column already used, so the database does not change.

Refs: nirun-life/nirun#135
---
 ni_observation/__manifest__.py                |  2 +-
 .../models/ni_observation_category.py         |  4 ++-
 .../report/ni_observation_report.py           |  2 +-
 .../tests/test_latest_observation.py          | 31 +++++++++++++++++++
 4 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/ni_observation/__manifest__.py b/ni_observation/__manifest__.py
index fb195d648..8d71445d7 100644
--- a/ni_observation/__manifest__.py
+++ b/ni_observation/__manifest__.py
@@ -3,7 +3,7 @@
 {
     "name": "Observation",
     "summary": "Clinical observations including vital signs, lab results, and measurements",
-    "version": "16.0.0.6.1",
+    "version": "16.0.0.6.2",
     "development_status": "Alpha",
     "category": "Healthcare",
     "author": "NSTDA, Piruin P.",
diff --git a/ni_observation/models/ni_observation_category.py b/ni_observation/models/ni_observation_category.py
index b15929acb..24eb6b811 100644
--- a/ni_observation/models/ni_observation_category.py
+++ b/ni_observation/models/ni_observation_category.py
@@ -8,7 +8,9 @@ class ObservationType(models.Model):
     _inherit = ["ni.coding"]
     _parent_store = True
 
-    parent_id = fields.Many2one("ni.observation.category", index=True, ondelete="")
+    parent_id = fields.Many2one(
+        "ni.observation.category", index=True, ondelete="set null"
+    )
     parent_path = fields.Char(index=True, unaccent=False)
 
     child_ids = fields.One2many("ni.observation.category", "parent_id", index=True)
diff --git a/ni_observation/report/ni_observation_report.py b/ni_observation/report/ni_observation_report.py
index 05606dee0..c1f47f5e3 100644
--- a/ni_observation/report/ni_observation_report.py
+++ b/ni_observation/report/ni_observation_report.py
@@ -54,7 +54,7 @@ class ObservationReport(models.AbstractModel):
 
     def _compute_observation(self):
         for rec in self:
-            obs = self.env["ni.observation"].browse(self.id)
+            obs = self.env["ni.observation"].browse(rec.id)
             if obs:
                 rec.update(
                     {
diff --git a/ni_observation/tests/test_latest_observation.py b/ni_observation/tests/test_latest_observation.py
index c5d90a197..f0628e1d4 100644
--- a/ni_observation/tests/test_latest_observation.py
+++ b/ni_observation/tests/test_latest_observation.py
@@ -73,3 +73,34 @@ def test_same_occurrence_picks_the_last_record(self):
             lambda o: o.type_id == self.type
         )
         self.assertEqual(rows.mapped("value_int"), [2])
+
+    def test_compute_observation_on_many_rows(self):
+        """Each latest row computes its own observation and history, also when
+        several rows are read together."""
+        other_type = self.type.copy({"name": "Latest Test 2", "code": "test-latest-2"})
+        first = self._observe(1, "2025-01-01 08:00:00")
+        last = self._observe(2, "2025-01-02 08:00:00")
+        other = self.env["ni.observation"].create(
+            {
+                "patient_id": self.patient.id,
+                "encounter_id": self.encounter.id,
+                "type_id": other_type.id,
+                "occurrence": "2025-01-02 08:00:00",
+                "value_int": 3,
+            }
+        )
+        self.env.flush_all()
+        self.env.invalidate_all()
+        rows = self.env["ni.patient.observation"].search(
+            [
+                ("patient_id", "=", self.patient.id),
+                ("type_id", "in", (self.type | other_type).ids),
+            ]
+        )
+        self.assertEqual(len(rows), 2)
+        by_type = {row.type_id: row for row in rows}
+        self.assertEqual(by_type[self.type].observation_id, last)
+        self.assertEqual(by_type[other_type].observation_id, other)
+        self.assertEqual(by_type[self.type].history_ids, last.history_ids)
+        self.assertIn(first, by_type[self.type].history_ids)
+        self.assertEqual(by_type[other_type].history_count, len(other.history_ids))

From cfa5c1581f6984881c10918a318bd79b9def3968 Mon Sep 17 00:00:00 2001
From: wachi <wasudd@gmail.com>
Date: Mon, 19 Oct 2026 12:37:20 +0700
Subject: [PATCH 5/7] [FIX] ni_questionnaire: compute the response counts as
 superuser

response_count on ni.patient and ni.encounter passed sudo_compute=True, which
is not a field parameter and was ignored. Use compute_sudo=True, as intended.
The counts now include completed responses the user cannot read through
record rules, the same as the other stored response computes of these models.

Refs: nirun-life/nirun#135
---
 ni_questionnaire/__manifest__.py        | 2 +-
 ni_questionnaire/models/ni_encounter.py | 2 +-
 ni_questionnaire/models/ni_patient.py   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/ni_questionnaire/__manifest__.py b/ni_questionnaire/__manifest__.py
index 216638780..27d860989 100644
--- a/ni_questionnaire/__manifest__.py
+++ b/ni_questionnaire/__manifest__.py
@@ -3,7 +3,7 @@
 {
     "name": "Questionnaire",
     "summary": "Patient questionnaires and survey administration",
-    "version": "16.0.0.5.0",
+    "version": "16.0.0.5.1",
     "development_status": "Alpha",
     "category": "Healthcare",
     "author": "NSTDA, Piruin P.",
diff --git a/ni_questionnaire/models/ni_encounter.py b/ni_questionnaire/models/ni_encounter.py
index fed28d078..a5e72a6c1 100644
--- a/ni_questionnaire/models/ni_encounter.py
+++ b/ni_questionnaire/models/ni_encounter.py
@@ -20,7 +20,7 @@ class Encounter(models.Model):
 
     response_count = fields.Integer(
         compute="_compute_response_count",
-        sudo_compute=True,
+        compute_sudo=True,
     )
 
     @api.depends("response_ids")
diff --git a/ni_questionnaire/models/ni_patient.py b/ni_questionnaire/models/ni_patient.py
index 23db62e5a..d85d11e6c 100644
--- a/ni_questionnaire/models/ni_patient.py
+++ b/ni_questionnaire/models/ni_patient.py
@@ -14,7 +14,7 @@ class Patient(models.Model):
     )
     response_count = fields.Integer(
         compute="_compute_response_count",
-        sudo_compute=True,
+        compute_sudo=True,
     )
     response_latest_ids = fields.One2many("ni.patient.survey_latest", "patient_id")
 

From 607413d2c269f670e7e057f5eb6f6b59914f2f4b Mon Sep 17 00:00:00 2001
From: wachi <wasudd@gmail.com>
Date: Mon, 19 Oct 2026 12:37:20 +0700
Subject: [PATCH 6/7] [FIX] ni_patient: encounter transfer date, "Until" filter
 and Error Entry

check_origin_date raised the translated message itself, a plain string, so
setting a transfer date without a transfer source failed with "exceptions must
derive from BaseException" instead of a validation error. It also compared the
transfer date (a Date) with the encounter start (a Datetime), which fails with
a TypeError on every encounter that has both, and on encounters without a start.
Raise ValidationError, and compare the transfer date with the start date in
the user's timezone, skipping the check when the encounter has no start.

The encounter search filter "Until" filtered on period_start; use period_end.

action_entered_in_error() wrote active=False. ni.encounter has no active field
of its own and inherits ni.patient.active through _inherits, so marking an
encounter as an error entry archived the patient. The state alone already marks
the encounter inactive (ENCOUNTER_INACTIVE_STATE).

Tests cover the transfer date and Error Entry.

Refs: nirun-life/nirun#135
---
 ni_patient/__manifest__.py                    |  2 +-
 ni_patient/models/ni_encounter.py             | 19 ++++--
 ni_patient/tests/__init__.py                  |  2 +
 .../test_ni_encounter_entered_in_error.py     | 26 +++++++
 .../tests/test_ni_encounter_origin_date.py    | 68 +++++++++++++++++++
 ni_patient/views/ni_encounter_views.xml       |  2 +-
 6 files changed, 113 insertions(+), 6 deletions(-)
 create mode 100644 ni_patient/tests/test_ni_encounter_entered_in_error.py
 create mode 100644 ni_patient/tests/test_ni_encounter_origin_date.py

diff --git a/ni_patient/__manifest__.py b/ni_patient/__manifest__.py
index cf094fc70..30bb33f1a 100644
--- a/ni_patient/__manifest__.py
+++ b/ni_patient/__manifest__.py
@@ -3,7 +3,7 @@
 {
     "name": "Patient",
     "summary": "Core patient data model, encounters, and encounter management",
-    "version": "16.0.0.4.0",
+    "version": "16.0.0.4.1",
     "development_status": "Alpha",
     "category": "Medical",
     "author": "NSTDA, Piruin P.",
diff --git a/ni_patient/models/ni_encounter.py b/ni_patient/models/ni_encounter.py
index e4550f70c..3dd019bd0 100644
--- a/ni_patient/models/ni_encounter.py
+++ b/ni_patient/models/ni_encounter.py
@@ -518,9 +518,20 @@ def _get_state_label(self):
     def check_origin_date(self):
         for rec in self:
             if rec.origin_date and not rec.origin_partner_id:
-                raise _("Transfer from must not be null when transfer at is present")
-            if rec.origin_date and rec.origin_date > rec.period_start:
-                raise _("Transfer date must not be after encounter start date")
+                raise ValidationError(
+                    _("Transfer from must not be null when transfer at is present")
+                )
+            # origin_date is a Date: compare it with the start date as the
+            # user sees it, not with the UTC datetime.
+            if (
+                rec.origin_date
+                and rec.period_start
+                and rec.origin_date
+                > fields.Datetime.context_timestamp(rec, rec.period_start).date()
+            ):
+                raise ValidationError(
+                    _("Transfer date must not be after encounter start date")
+                )
 
     @api.constrains(
         "discharge_status_id",
@@ -729,7 +740,7 @@ def action_close(self, vals=None):
             )
 
     def action_entered_in_error(self):
-        self.write({"state": "entered-in-error", "active": False})
+        self.write({"state": "entered-in-error"})
 
     def action_reset_to_draft(self):
         self.write({"state": "draft"})
diff --git a/ni_patient/tests/__init__.py b/ni_patient/tests/__init__.py
index e125ed01f..dd203767f 100644
--- a/ni_patient/tests/__init__.py
+++ b/ni_patient/tests/__init__.py
@@ -3,6 +3,8 @@
 from . import (
     test_ni_encounter_class_auto_close,
     test_ni_encounter_class_auto_close_edge_cases,
+    test_ni_encounter_entered_in_error,
+    test_ni_encounter_origin_date,
     test_ni_location_name_search,
     test_ni_patient,
     test_ni_patient_archive_wizard,
diff --git a/ni_patient/tests/test_ni_encounter_entered_in_error.py b/ni_patient/tests/test_ni_encounter_entered_in_error.py
new file mode 100644
index 000000000..ebb750a58
--- /dev/null
+++ b/ni_patient/tests/test_ni_encounter_entered_in_error.py
@@ -0,0 +1,26 @@
+#  Copyright (c) 2026 NSTDA
+
+from odoo.tests import common
+
+
+class TestEncounterEnteredInError(common.TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        partner = cls.env["res.partner"].create({"name": "Error Entry Patient"})
+        cls.patient = cls.env["ni.patient"].create({"partner_id": partner.id})
+        cls.enc_class = cls.env["ni.encounter.class"].search([], limit=1)
+
+    def _make_encounter(self, **vals):
+        return self.env["ni.encounter"].create(
+            dict(
+                {"patient_id": self.patient.id, "class_id": self.enc_class.id},
+                **vals,
+            )
+        )
+
+    def test_entered_in_error_keeps_the_patient_active(self):
+        encounter = self._make_encounter()
+        encounter.action_entered_in_error()
+        self.assertEqual(encounter.state, "entered-in-error")
+        self.assertTrue(self.patient.active)
diff --git a/ni_patient/tests/test_ni_encounter_origin_date.py b/ni_patient/tests/test_ni_encounter_origin_date.py
new file mode 100644
index 000000000..8b7c8ef6c
--- /dev/null
+++ b/ni_patient/tests/test_ni_encounter_origin_date.py
@@ -0,0 +1,68 @@
+#  Copyright (c) 2026 NSTDA
+
+from datetime import date, datetime
+
+from odoo.exceptions import ValidationError
+from odoo.tests import common
+
+
+class TestEncounterOriginDate(common.TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.env = cls.env(context=dict(cls.env.context, tz="Asia/Bangkok"))
+        cls.partner = cls.env["res.partner"].create({"name": "Origin Date Patient"})
+        cls.patient = cls.env["ni.patient"].create({"partner_id": cls.partner.id})
+        cls.hospital = cls.env["res.partner"].create(
+            {"name": "Origin Hospital", "is_company": True}
+        )
+        cls.enc_class = cls.env["ni.encounter.class"].search([], limit=1)
+
+    def _make_encounter(self, **vals):
+        return self.env["ni.encounter"].create(
+            dict(
+                {"patient_id": self.patient.id, "class_id": self.enc_class.id},
+                **vals,
+            )
+        )
+
+    def test_origin_date_requires_origin_partner(self):
+        with self.assertRaises(ValidationError):
+            self._make_encounter(origin_date=date(2026, 10, 1))
+
+    def test_origin_date_after_period_start(self):
+        with self.assertRaises(ValidationError):
+            self._make_encounter(
+                origin_partner_id=self.hospital.id,
+                origin_date=date(2026, 10, 2),
+                period_start=datetime(2026, 10, 1, 3, 0),
+            )
+
+    def test_origin_date_on_or_before_period_start(self):
+        for origin_date in (date(2026, 9, 30), date(2026, 10, 1)):
+            encounter = self._make_encounter(
+                origin_partner_id=self.hospital.id,
+                origin_date=origin_date,
+                period_start=datetime(2026, 10, 1, 3, 0),
+            )
+            self.assertEqual(encounter.origin_date, origin_date)
+
+    def test_origin_date_uses_user_timezone(self):
+        # 2026-10-01 20:00 UTC is 2026-10-02 03:00 in Bangkok.
+        encounter = self._make_encounter(
+            origin_partner_id=self.hospital.id,
+            origin_date=date(2026, 10, 2),
+            period_start=datetime(2026, 10, 1, 20, 0),
+        )
+        self.assertEqual(encounter.origin_date, date(2026, 10, 2))
+
+    def test_origin_date_without_period_start(self):
+        encounter = self._make_encounter(period_start=datetime(2026, 10, 1, 3, 0))
+        encounter.write(
+            {
+                "period_start": False,
+                "origin_partner_id": self.hospital.id,
+                "origin_date": date(2026, 10, 2),
+            }
+        )
+        self.assertEqual(encounter.origin_date, date(2026, 10, 2))
diff --git a/ni_patient/views/ni_encounter_views.xml b/ni_patient/views/ni_encounter_views.xml
index 6290da169..98d139ecb 100644
--- a/ni_patient/views/ni_encounter_views.xml
+++ b/ni_patient/views/ni_encounter_views.xml
@@ -68,7 +68,7 @@
                 <field name="location_id" />
                 <separator />
                 <filter name="period_start" string="Since" date="period_start" />
-                <filter name="period_end" string="Until" date="period_start" />
+                <filter name="period_end" string="Until" date="period_end" />
                 <separator />
                 <filter
                     name="encounter"

From 2e2b24c755e07e5f2291387aa57eeb512c1b92fb Mon Sep 17 00:00:00 2001
From: wachi <wasudd@gmail.com>
Date: Wed, 21 Oct 2026 08:46:22 +0700
Subject: [PATCH 7/7] [IMP] tools: list patients archived by Error Entry, drop
 start-date workaround

Add a read-only query that lists the patients "Error Entry" may have archived
by mistake (archived, no state reason, an entered-in-error encounter). Support
reviews the list and reactivates the confirmed patients from the UI; nothing is
reactivated automatically. The output holds patient identifiers, so it stays in
support's own channel.

The pilot sample data no longer sets period_start_date by hand: since the
ni_period fix the compute gives the date of period_start on create.

Refs: nirun-life/nirun#135
---
 .tools/error_entry_archived_patients.sql | 28 ++++++++++++++++++++++++
 .tools/migration_sample_data_p1.py       |  5 -----
 2 files changed, 28 insertions(+), 5 deletions(-)
 create mode 100644 .tools/error_entry_archived_patients.sql

diff --git a/.tools/error_entry_archived_patients.sql b/.tools/error_entry_archived_patients.sql
new file mode 100644
index 000000000..8c9dfabac
--- /dev/null
+++ b/.tools/error_entry_archived_patients.sql
@@ -0,0 +1,28 @@
+-- Copyright (c) 2026 NSTDA
+--
+-- Patients that "Error Entry" may have archived by mistake (nirun-life/nirun#135, F4).
+--
+-- From b25bb607 (2023-12-20) until the 16.0 fix, marking an encounter as
+-- entered-in-error also archived its patient, and through _inherits that hid all
+-- of the patient's encounters. The archive wizard always sets state_reason_id, so
+-- an archived patient without one that has an entered-in-error encounter is a
+-- likely victim.
+--
+-- Read-only. Nothing is reactivated automatically: support checks each patient
+-- and reactivates the confirmed ones from the UI, so the change is tracked in the
+-- chatter. Run it before the OpenUpgrade 16 -> 17 step:
+--
+--     psql -d <database> -f .tools/error_entry_archived_patients.sql
+--
+-- The output holds patient identifiers. Share it only through support's own
+-- channel, never in an issue, a pull request or a log attached to one.
+
+SELECT p.id, p.identifier
+FROM ni_patient p
+WHERE p.active IS NOT TRUE
+  AND p.state_reason_id IS NULL
+  AND EXISTS (
+      SELECT 1 FROM ni_encounter e
+      WHERE e.patient_id = p.id AND e.state = 'entered-in-error'
+  )
+ORDER BY p.id;
diff --git a/.tools/migration_sample_data_p1.py b/.tools/migration_sample_data_p1.py
index 7522a714e..3683ad864 100644
--- a/.tools/migration_sample_data_p1.py
+++ b/.tools/migration_sample_data_p1.py
@@ -188,15 +188,11 @@ def encounter(patient, klass, start, location=None):
         "patient_id": patient.id,
         "class_id": klass.id,
         "period_start": start,
-        # ni.period.mixin gives period_start_date a default (today), which wins
-        # over its compute when a record is created from code.
-        "period_start_date": start.date(),
         "location_id": (location or locations[0]).id,
     }
     if patient.other_address_id:
         vals["other_address_id"] = patient.other_address_id.id
     enc = env["ni.encounter"].create(vals)
-    enc.location_history_ids.write({"period_start_date": start.date()})
     enc.participant_ids = [
         (
             0,
@@ -204,7 +200,6 @@ def encounter(patient, klass, start, location=None):
             {
                 "employee_id": employees[0].id,
                 "period_start": start,
-                "period_start_date": start.date(),
             },
         )
     ]