Let a typed employee name find the employee

Reported from the floor: somebody types the employee's whole name into the
notification or recognition picker and presses Enter instead of clicking the
suggestion, and the entry does not pull from the employee database.

Two causes, one symptom.

The search matched the WHOLE query against first name or last name, so "Dana
Reyes" found nobody - no single column holds that string. Typing a full name is
what a person does before pressing Enter, and it was the one thing guaranteed to
return an empty list. A multi-word query is now treated as a full name: every
word must appear somewhere in the name, in either column, so "Reyes Dana" works
too, and "Dana Reyes" does not also return Sam Reyes. A single word still
searches broadly, and an SSO still resolves. Both directory backends changed,
the self-hosted tables and the external HR database.

With no suggestion to click, the form then turned the typed text into
`NAME:<text>` - a label linked to nothing. On screen that chip is identical to a
real selection; the difference only shows up later as no photo, no directory
link, and a recognition the person it is about cannot be found by. Both pickers
(the notifications form and the shared EmployeeSearch component) now look a
typed name up before deciding it is free text, through one helper.

An exact full-name match wins over a longer partial one, because somebody typing
"Dana Reyes" means that person and not "Dana Reyes-Smith". A genuinely ambiguous
name is NOT guessed at - the candidates are shown and the operator picks, which
is exactly when picking wrong matters most. A directory that cannot be reached
reports failure rather than silently producing a label.

Eleven tests. The search rules verified by planting the single-term query back.

One note for whoever reads the spec: the failure-branch test uses a thenable
that rejects rather than a mock returning a rejected promise. The runner
collects such a promise as an unhandled error even when the code under test
catches it, and fails the very test that proves the catch works.

Scope: product

tests/test_core/test_employees.py

@@ -24,3 +24,84 @@ def test_search_degrades_when_directory_unreachable(client, db, auth_headers):
     resp = client.get('/api/employees/search?q=smith', headers=auth_headers)
     assert resp.status_code == 500
     assert resp.get_json()['status'] == 'error'
+
+
+# --- a full name has to find the person -------------------------------------
+#
+# Reported from the floor: somebody types the employee's whole name into the
+# notification/recognition picker and presses Enter instead of clicking the
+# suggestion, and the entry does not pull from the employee database.
+#
+# Two causes, one symptom. The search matched the whole query against first
+# name OR last name, so "Dana Reyes" matched nothing - no single column holds
+# that string - and with no suggestion to click, the form turned the typed text
+# into a free-text label with no SSO: no photo, no directory link, and a
+# recognition the person it is about cannot be found by.
+
+def _seed(db, first, last, sso):
+    """One directory employee, in self-hosted mode.
+
+    The mode matters: without it the search goes to the external HR database,
+    which does not exist here and answers 500.
+    """
+    from shopdb.core.models import Setting
+    from plugins.employees.models import DirectoryEmployee
+
+    row = Setting.query.filter_by(key='employee_directory_mode').first()
+    if row is None:
+        db.session.add(Setting(key='employee_directory_mode',
+                               value='selfhosted', valuetype='string',
+                               category='site'))
+    else:
+        row.value = 'selfhosted'
+    db.session.add(DirectoryEmployee(sso=sso, firstname=first, lastname=last))
+    db.session.commit()
+
+
+def test_a_full_name_finds_the_employee(client, db, auth_headers):
+    _seed(db, 'Dana', 'Reyes', 990001)
+
+    response = client.get('/api/employees/search?q=Dana%20Reyes',
+                          headers=auth_headers)
+    assert response.status_code == 200, response.get_json()
+    rows = response.get_json()['data']
+    assert [str(r['SSO']) for r in rows] == ['990001']
+
+
+def test_the_words_may_be_in_either_order(client, db, auth_headers):
+    """A directory that lists "Reyes, Dana" trains people to type it that way."""
+    _seed(db, 'Dana', 'Reyes', 990002)
+
+    rows = client.get('/api/employees/search?q=Reyes%20Dana',
+                      headers=auth_headers).get_json()['data']
+    assert [str(r['SSO']) for r in rows] == ['990002']
+
+
+def test_every_word_must_match_so_a_full_name_is_not_a_broad_search(
+        client, db, auth_headers):
+    """"Dana Reyes" must not also return Sam Reyes - that is what makes the
+    result unambiguous enough to select automatically."""
+    _seed(db, 'Dana', 'Reyes', 990003)
+    _seed(db, 'Sam', 'Reyes', 990004)
+
+    rows = client.get('/api/employees/search?q=Dana%20Reyes',
+                      headers=auth_headers).get_json()['data']
+    assert [str(r['SSO']) for r in rows] == ['990003']
+
+
+def test_a_single_word_still_searches_broadly(client, db, auth_headers):
+    """One word is a search, not a name: it must still find every match."""
+    _seed(db, 'Dana', 'Reyes', 990005)
+    _seed(db, 'Sam', 'Reyes', 990006)
+
+    rows = client.get('/api/employees/search?q=Reyes',
+                      headers=auth_headers).get_json()['data']
+    assert len(rows) == 2
+
+
+def test_an_sso_still_resolves(client, db, auth_headers):
+    _seed(db, 'Dana', 'Reyes', 990007)
+
+    rows = client.get('/api/employees/search?q=990007',
+                      headers=auth_headers).get_json()['data']
+    assert [str(r['SSO']) for r in rows] == ['990007']

tests/test_core/test_identifiers.py

@@ -75,3 +75,73 @@ def test_per_type_identifier_seed_count(client, db, auth_headers):
     }
     assert expected <= keys
     assert len(expected) == len(IDENTIFIER_LABELS) * len(IDENTIFIER_ASSETTYPES)
+
+
+# --- owned location versus inherited location -------------------------------
+#
+# Asset.to_dict merges an inherited location into locationid/mapx/mapy/levelid
+# when the asset has none of its own. That is right for a reader - a detail
+# page, a list and the map all want the resolved location - and wrong for a
+# FORM, which reads the same payload and cannot tell an owned value from a
+# derived one. The PC form pre-selected an inherited location and saved it back
+# as the record's own, so an edit that never touched location silently stopped
+# the PC following its parent.
+
+def test_an_asset_payload_says_what_it_owns_as_well_as_what_it_resolves_to(
+        db, app):
+    from shopdb.core.models import Asset, AssetType, Location, RelationshipType
+    from shopdb.core.models.relationship import AssetRelationship
+
+    with app.app_context():
+        assettype = AssetType(assettype='machine')
+        location = Location(locationname='Bay 7')
+        db.session.add_all([assettype, location])
+        db.session.flush()
+
+        parent = Asset(assetnumber='OWN-PARENT', assettypeid=assettype.assettypeid,
+                       locationid=location.locationid, mapx=10, mapy=20)
+        child = Asset(assetnumber='OWN-CHILD', assettypeid=assettype.assettypeid)
+        db.session.add_all([parent, child])
+        db.session.flush()
+
+        controls = RelationshipType.query.filter_by(
+            relationshiptype='controls').first()
+        if controls is None:
+            controls = RelationshipType(relationshiptype='controls',
+                                        isdirectional=True)
+            db.session.add(controls)
+            db.session.flush()
+        db.session.add(AssetRelationship(
+            sourceassetid=child.assetid, targetassetid=parent.assetid,
+            relationshiptypeid=controls.relationshiptypeid))
+        db.session.commit()
+
+        payload = child.to_dict()
+
+    # What it OWNS: nothing. That is the value a form must bind to.
+    assert payload['ownlocationid'] is None
+    assert payload['ownmapx'] is None
+    assert payload['ownmapy'] is None
+    assert payload['ownlevelid'] is None
+
+
+def test_the_owned_values_are_present_even_with_nothing_inherited(db, app):
+    """A client binds to them unconditionally, so they cannot appear only when
+    inheritance happens to be in play."""
+    from shopdb.core.models import Asset, AssetType, Location
+
+    with app.app_context():
+        assettype = AssetType(assettype='machine')
+        location = Location(locationname='Bay 9')
+        db.session.add_all([assettype, location])
+        db.session.flush()
+        asset = Asset(assetnumber='OWN-PLAIN', assettypeid=assettype.assettypeid,
+                      locationid=location.locationid, mapx=5, mapy=6)
+        db.session.add(asset)
+        db.session.commit()
+
+        payload = asset.to_dict()
+
+    assert payload['ownlocationid'] == payload['locationid']
+    assert payload['ownmapx'] == 5
+    assert payload['ownmapy'] == 6