Hire-to-retire: where people data meets logistics and finance

Calder sample pack 1.0: order 1000001, net 29,100.00 USD, cost 19,600.00 USD.
All data is fictional. Next: python check_unit1b.py

"""Hire to retire at Calder: where people data crosses into logistics and finance.

Calder Pumpworks is a fictional company. The pack (unit1b/calder_pack/) and the
scenario below (employees, cost centers, payroll totals, time records, expense
reports, absences) are made up for the course. Field names follow SAP's released
APIs where the script mirrors one (API_MANAGE_WORKFORCE_TIMESHEET, the workforce
and business partner models), but the logic is a teaching sketch, not SAP's.
Personnel numbers, G/L accounts, cost centers, report IDs and skill tags are
course labels, not SAP values. On purpose, the script holds no names, no
addresses and no individual pay: only what each crossing needs.

Run it from your course folder:
  python unit1b/hire_to_retire.py               the crossings check for CP10 on 2026-11-02
  python unit1b/hire_to_retire.py --payroll     October payroll posting document by cost center
  python unit1b/hire_to_retire.py --time        technician time waiting to reach maintenance orders
  python unit1b/hire_to_retire.py --expenses    expense reports waiting to post
  python unit1b/hire_to_retire.py --ai          what a scheduling assistant may see, minimized
  python unit1b/hire_to_retire.py --write       write unit1b/calder_people_crossings.md
  python unit1b/hire_to_retire.py --sandbox     read timesheet records from SAP's sandbox (needs SAP_API_KEY)
Steps without --sandbox use only Python's built-in modules and need no account and no network.
"""
import argparse
import hashlib
import hmac
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path

HERE = Path(__file__).resolve().parent
PACK = HERE / "calder_pack"
AS_OF = "2026-11-02"            # Monday, workday 1 of the October close
PERIOD = "2026-10"

# ------------------------------------------------------------ the fixes (the exercise changes these)
# Has cost center replication from S/4HANA to the HR system run again since CP11-435 closed?
CC_REPLICATION_RUN = False
# New cost centers HR enters for people still on a closed cost center: {personnel number: cost center}
HR_FIXES = {}

# ------------------------------------------------------------ cost centers (fictional, controlling area CP00)
# S/4HANA CP10 is the system of record for cost centers. (cost center, name, valid from, valid to)
S4_COST_CENTERS = [
    ("CP11-300", "Rockford purchasing", "2020-01-01", "9999-12-31"),
    ("CP11-410", "Assembly", "2020-01-01", "9999-12-31"),
    ("CP11-420", "Test", "2020-01-01", "9999-12-31"),
    ("CP11-435", "Rework area", "2023-01-01", "2026-09-30"),   # closed: rework moved into assembly
    ("CP11-450", "Plant maintenance", "2020-01-01", "9999-12-31"),
    ("CP11-460", "Utilities", "2020-01-01", "9999-12-31"),
    ("CP11-900", "Rockford administration", "2020-01-01", "9999-12-31"),
]
# What the HR system last received. The replication job last succeeded on 2026-09-14.
HR_CC_LAST_REPLICATED = "2026-09-14"


def hr_cost_centers() -> dict:
    if CC_REPLICATION_RUN:
        return {cc: (vf, vt) for cc, _, vf, vt in S4_COST_CENTERS}
    return {cc: (vf, "9999-12-31" if cc == "CP11-435" else vt) for cc, _, vf, vt in S4_COST_CENTERS}


def s4_valid(cc: str, on: str) -> bool:
    return any(c == cc and vf <= on <= vt for c, _, vf, vt in S4_COST_CENTERS)


# ------------------------------------------------------------ people (fictional, CP10 Rockford operations, a subset)
# The HR system (Employee Central in this course) is the system of record for people.
# (personnel number, job, work center, cost center, employment start, employment end or "")
HR_EMPLOYEES = [
    ("00100094", "Maintenance technician", "MECH1", "CP11-450", "2019-03-04", "2026-10-16"),
    ("00100117", "Maintenance technician", "MECH1", "CP11-450", "2018-06-11", ""),
    ("00100142", "Maintenance electrician", "ELEC1", "CP11-450", "2021-02-01", ""),
    ("00100153", "Maintenance planner", "", "CP11-450", "2017-09-18", ""),
    ("00100188", "Assembler", "ASSY1", "CP11-410", "2022-04-25", ""),
    ("00100196", "Test technician", "TEST1", "CP11-420", "2020-08-03", ""),
    ("00100205", "Rework technician", "ASSY1", "CP11-435", "2023-01-09", ""),
    ("00100211", "Buyer", "", "CP11-300", "2024-05-13", ""),
    ("00100231", "Maintenance technician", "MECH1", "CP11-435", "2026-10-19", ""),  # new hire, reused rework position
]
# S/4HANA business users linked to these people: (personnel number, user valid to)
BUSINESS_USERS = [("00100094", "9999-12-31"), ("00100117", "9999-12-31"), ("00100142", "9999-12-31"),
                  ("00100153", "9999-12-31"), ("00100211", "9999-12-31")]


def hr_people() -> list:
    return [(p, job, wc, HR_FIXES.get(p, cc), start, end) for p, job, wc, cc, start, end in HR_EMPLOYEES]


def replicate() -> tuple:
    """Employee replication HR -> S/4HANA: one employee and one employment business partner per person.
    In this scenario S/4HANA rejects a record whose cost center isn't valid on the employment start."""
    s4, rejected = {}, {}
    for p, job, wc, cc, start, end in hr_people():
        existed_before = start < "2026-10-01"
        check_date = start if not existed_before else "2026-10-01"
        if not existed_before and not s4_valid(cc, check_date):
            rejected[p] = f"cost center {cc} not valid on {check_date}"
            continue
        s4[p] = {"WorkCenter": wc, "CostCenter": cc, "Start": start, "End": end,
                 "BPRoles": ["BUP003", "BUP010"]}       # employee, employment
    return s4, rejected


# ------------------------------------------------------------ payroll (fictional, summarized by cost center)
# October payroll posting document from the payroll system, posting date 2026-10-30, USD.
# Lines: (G/L account, name, cost center, debit, credit). Accounts are course labels.
GL_WAGES, GL_ER_TAX = "61100000", "61200000"
PAYROLL_BY_CC = {   # cost center: (wages and salaries, employer payroll taxes)
    "CP11-300": (18400.00, 1410.00), "CP11-410": (96300.00, 7370.00), "CP11-420": (31200.00, 2390.00),
    "CP11-435": (6830.00, 520.00), "CP11-450": (38900.00, 2980.00), "CP11-900": (27600.00, 2110.00),
}
PAYROLL_CREDITS = [("21500000", "Net pay payable", 158640.00),
                   ("21600000", "Employee withholdings payable", 60590.00),
                   ("21700000", "Employer payroll taxes payable", 16780.00)]
# When HR moves the people off CP11-435, the payroll system recalculates the posting.
# The payroll system's re-run moves these totals (course values). Note what they reveal (see the topic).
REPOST_IF_FIXED = {"00100205": ("CP11-410", 4610.00, 350.00), "00100231": ("CP11-450", 2220.00, 170.00)}


def payroll_lines() -> list:
    by_cc = {cc: list(v) for cc, v in PAYROLL_BY_CC.items()}
    people = {p: cc for p, _, _, cc, _, _ in hr_people()}
    for p, (new_cc, wages, tax) in REPOST_IF_FIXED.items():
        if people[p] == new_cc:
            by_cc["CP11-435"][0] -= wages
            by_cc["CP11-435"][1] -= tax
            by_cc[new_cc][0] += wages
            by_cc[new_cc][1] += tax
    lines = []
    for cc in sorted(by_cc):
        wages, tax = (round(x, 2) for x in by_cc[cc])
        if wages or tax:
            lines.append((GL_WAGES, "Wages and salaries", cc, wages, 0.0))
            lines.append((GL_ER_TAX, "Employer payroll taxes", cc, tax, 0.0))
    lines += [(gl, name, "", 0.0, amount) for gl, name, amount in PAYROLL_CREDITS]
    return lines


def check_payroll() -> dict:
    lines = payroll_lines()
    debit = round(sum(l[3] for l in lines), 2)
    credit = round(sum(l[4] for l in lines), 2)
    bad = [l for l in lines if l[2] and not s4_valid(l[2], "2026-10-30")]
    return {"lines": lines, "debit": debit, "credit": credit, "bad": bad,
            "held": round(sum(l[3] for l in bad), 2), "posts": debit == credit and not bad}


# ------------------------------------------------------------ time (fictional)
# Time recorded by technicians, waiting to become confirmations on maintenance orders.
# (record, personnel number, date, order, work center, hours). MECH1 95.00 and ELEC1 105.00 USD/h.
RATES = {"MECH1": 95.00, "ELEC1": 105.00}
TIME_RECORDS = [
    ("T-5101", "00100117", "2026-10-26", "4000126", "MECH1", 6.0),
    ("T-5102", "00100142", "2026-10-26", "4000126", "ELEC1", 3.5),
    ("T-5103", "00100231", "2026-10-27", "4000126", "MECH1", 8.0),
    ("T-5104", "00100231", "2026-10-28", "4000126", "MECH1", 6.0),
    ("T-5105", "00100094", "2026-10-20", "4000126", "MECH1", 4.0),
]


def check_time(s4: dict) -> list:
    out = []
    for rec, p, day, order, wc, hours in TIME_RECORDS:
        cost = hours * RATES[wc]
        if p not in s4:
            out.append((rec, p, day, order, hours, cost, "blocked", "personnel number not in S/4HANA"))
        elif s4[p]["End"] and day > s4[p]["End"]:
            out.append((rec, p, day, order, hours, cost, "check", f"date after employment end {s4[p]['End']}"))
        else:
            out.append((rec, p, day, order, hours, cost, "confirmed", "activity allocation to the order"))
    return out


# ------------------------------------------------------------ travel and expenses (fictional)
# Expense reports approved in the expense system, waiting to post to CP10. (report, personnel number, purpose, cost center, USD)
EXPENSE_REPORTS = [
    ("ER-2026-0412", "00100117", "Crane inspection training, Chicago", "CP11-450", 642.18),
    ("ER-2026-0415", "00100094", "Seal supplier visit, 28 Sep - 2 Oct", "CP11-450", 2318.40),
    ("ER-2026-0419", "00100231", "Safety boots and induction travel", "CP11-435", 486.75),
]


def check_expenses(s4: dict) -> list:
    out = []
    people = {p: cc for p, _, _, cc, _, _ in hr_people()}
    for rep, p, purpose, cc, amount in EXPENSE_REPORTS:
        if p == "00100231" and p in HR_FIXES:
            cc = people[p]          # the expense system takes the default cost center from HR
        problems = []
        if p not in s4:
            problems.append("no employee business partner or supplier role for reimbursement")
        if not s4_valid(cc, AS_OF):
            problems.append(f"cost center {cc} closed")
        note = "; ".join(problems) if problems else (
            "employment ended: keep the supplier role payable until reimbursed"
            if p in s4 and s4[p]["End"] else "")
        out.append((rep, p, purpose, cc, amount, "blocked" if problems else "posts", note))
    return out


# ------------------------------------------------------------ the crossings check
def money(x: float) -> str:
    return f"{x:,.2f}"


def check_pack() -> None:
    try:
        org = json.loads((PACK / "org_units.json").read_text(encoding="utf-8"))
    except FileNotFoundError:
        sys.exit(f"Cannot read {PACK}. Run: python unit1b/make_calder_pack.py (Unit 1B setup).")
    codes = {c["CompanyCode"]: c for c in org["CompanyCodes"]}
    if set(codes) != {"CP10", "CP20"} or codes["CP20"]["System"] != "ECC":
        sys.exit("Company codes CP10 (S/4HANA) and CP20 (ECC) are missing from the pack. Run make_calder_pack.py again.")
    if not any(a["ControllingArea"] == "CP00" for a in org["ControllingAreas"]):
        sys.exit("Controlling area CP00 is missing from the pack. Run make_calder_pack.py again.")


def findings() -> list:
    """Each finding: (id, crossing, what, owner, root cause)."""
    s4, rejected = replicate()
    hr_cc = hr_cost_centers()
    found = []
    for cc, (_, vt) in sorted(hr_cc.items()):
        s4_vt = next(v for c, _, _, v in S4_COST_CENTERS if c == cc)
        if vt != s4_vt:
            users = [p for p, _, _, c, _, _ in hr_people() if c == cc]
            found.append(("cost centers S/4HANA -> HR",
                          f"{cc} closed in S/4HANA on {s4_vt}, still open in HR (last replicated "
                          f"{HR_CC_LAST_REPLICATED}); {len(users)} people assigned", "HR integration team",
                          "cost center replication"))
    for p, why in sorted(rejected.items()):
        found.append(("employees HR -> S/4HANA", f"{p} hired, not in S/4HANA: {why}",
                      "HR integration team", "cost center replication"))
    for p, rec in sorted(s4.items()):
        if not s4_valid(rec["CostCenter"], AS_OF) and not rec["End"]:
            found.append(("employees HR -> S/4HANA", f"{p} assigned to closed cost center {rec['CostCenter']}",
                          "HR, with the cost accountant", "cost center replication"))
    for p, valid_to in BUSINESS_USERS:
        if p in s4 and s4[p]["End"] and valid_to > s4[p]["End"]:
            found.append(("leaver -> access", f"{p} left on {s4[p]['End']}; S/4HANA business user still valid",
                          "Security administrator", "leaver process"))
    pay = check_payroll()
    if not pay["posts"]:
        ccs = sorted({l[2] for l in pay["bad"]})
        found.append(("payroll -> finance", f"October posting held: {money(pay['held'])} USD on {', '.join(ccs)}",
                      "Payroll, with the G/L accountant", "cost center replication"))
    for rec, p, day, order, hours, cost, status, why in check_time(s4):
        if status != "confirmed":
            root = "cost center replication" if status == "blocked" else "time entry"
            found.append(("time -> maintenance orders", f"{rec}: {hours:.1f} h by {p} on order {order} ({why})",
                          "Maintenance supervisor", root))
    for rep, p, purpose, cc, amount, status, why in check_expenses(s4):
        if status == "blocked":
            found.append(("expenses -> finance", f"{rep}: {money(amount)} USD for {p} ({why})",
                          "Travel and expense admin", "cost center replication"))
    return [(f"H{i}", *f) for i, f in enumerate(found, 1)]


def print_check() -> None:
    s4, _ = replicate()
    found = findings()
    print(f"Calder Pumpworks (fictional), CP10 people-data crossings on {AS_OF}")
    print(f"HR records: {len(HR_EMPLOYEES)}   in S/4HANA: {len(s4)}   findings: {len(found)}\n")
    for fid, crossing, what, owner, root in found:
        print(f"  {fid:<4}{crossing:<28}{what}")
        print(f"      owner: {owner:<34}root cause: {root}")
    roots = {}
    for f in found:
        roots[f[4]] = roots.get(f[4], 0) + 1
    print("\n  By root cause: " + ", ".join(f"{r} {n}" for r, n in sorted(roots.items(), key=lambda x: -x[1])))


def print_payroll() -> None:
    pay = check_payroll()
    print(f"October payroll posting document for CP10 (fictional), posting date 2026-10-30\n")
    print(f"  {'G/L':<10}{'Account':<32}{'Cost center':<13}{'Debit':>12}{'Credit':>12}  check")
    for gl, name, cc, d, c in pay["lines"]:
        flag = "" if not cc else ("ok" if s4_valid(cc, "2026-10-30") else "closed")
        print(f"  {gl:<10}{name:<32}{cc:<13}{money(d) if d else '':>12}{money(c) if c else '':>12}  {flag}")
    print(f"\n  Debits {money(pay['debit'])}   credits {money(pay['credit'])}   "
          f"{'balanced' if pay['debit'] == pay['credit'] else 'NOT balanced'}")
    if pay["posts"]:
        print("  Result: the document posts to CP10.")
    else:
        print(f"  Result: held. {money(pay['held'])} USD sits on a cost center that is closed in S/4HANA;")
        print("  in this scenario the whole document waits, so October payroll is missing from CP10's books.")


def print_time() -> None:
    s4, _ = replicate()
    rows = check_time(s4)
    print("Technician time for maintenance orders (fictional), October 2026\n")
    for rec, p, day, order, hours, cost, status, why in rows:
        print(f"  {rec:<8}{p:<10}{day:<12}{order:<9}{hours:>5.1f} h{money(cost):>10}  {status:<10}{why}")
    for status in ("confirmed", "blocked", "check"):
        h = sum(r[4] for r in rows if r[6] == status)
        c = sum(r[5] for r in rows if r[6] == status)
        print(f"\n  {status:<10}{h:>5.1f} h{money(c):>10} USD", end="")
    print("\n\n  Blocked hours are real work missing from the order's cost until the person exists in S/4HANA.")


def print_expenses() -> None:
    s4, _ = replicate()
    print("Expense reports waiting to post to CP10 (fictional)\n")
    for rep, p, purpose, cc, amount, status, why in check_expenses(s4):
        print(f"  {rep:<14}{p:<10}{cc:<10}{money(amount):>10}  {status:<8}{why}")


# ------------------------------------------------------------ AI grounding: what may cross
# Fields a planned maintenance scheduling assistant asked for, and the decision per field.
# allow: needed and low risk. pseudonymize: needed to join records, never shown as is. exclude: not needed or sensitive.
AI_FIELD_POLICY = [
    ("PersonnelNumber", "pseudonymize", "needed to join records; the assistant sees a token"),
    ("WorkCenter", "allow", "decides which orders a person can work on"),
    ("SkillTags", "allow", "job-related qualifications"),
    ("PlannedWorkingHours", "allow", "capacity per day"),
    ("AvailableOnDay", "allow", "yes or no per day, derived from absences"),
    ("AbsenceType", "exclude", "can reveal health or family matters; availability is enough"),
    ("CostCenter", "exclude", "not needed to schedule"),
    ("PayGrade", "exclude", "pay data; never needed to schedule"),
    ("HomeAddress", "exclude", "personal data; not needed"),
    ("DateOfBirth", "exclude", "personal data; not needed"),
    ("BankAccount", "exclude", "payment data; not needed"),
]
SKILLS = {"00100094": ["hydraulics"], "00100117": ["hydraulics", "crane inspection"],
          "00100142": ["electrical", "PLC"], "00100231": ["hydraulics"]}
# Absences in the HR system for the overhaul week 9-13 Nov (the type stays in HR).
ABSENCES = {("00100117", "2026-11-10"): "sick leave",
            ("00100142", "2026-11-12"): "vacation", ("00100142", "2026-11-13"): "vacation"}
WEEK = ["2026-11-09", "2026-11-10", "2026-11-11", "2026-11-12", "2026-11-13"]
# The pseudonym key comes from the environment. The course default keeps your output
# identical to the topic; a real system reads it from a secret store and has no default.
PSEUDONYM_KEY = os.environ.get("CALDER_PSEUDONYM_KEY", "calder-course-only").encode()


def token(p: str) -> str:
    return "T-" + hmac.new(PSEUDONYM_KEY, p.encode(), hashlib.sha256).hexdigest()[:8]


def ai_view() -> list:
    s4, _ = replicate()
    rows = []
    for p, rec in sorted(s4.items()):
        if rec["WorkCenter"] not in RATES or (rec["End"] and rec["End"] < WEEK[0]):
            continue
        rows.append({"Person": token(p), "WorkCenter": rec["WorkCenter"], "SkillTags": SKILLS.get(p, []),
                     "PlannedWorkingHours": 8.0,
                     "AvailableOnDay": {d[5:]: (p, d) not in ABSENCES for d in WEEK}})
    return rows


def print_ai() -> None:
    print("Field decisions for the maintenance scheduling assistant (course policy)\n")
    for field, decision, why in AI_FIELD_POLICY:
        print(f"  {field:<22}{decision:<14}{why}")
    rows = ai_view()
    print(f"\nWhat the assistant receives for the overhaul week, {len(rows)} technicians:\n")
    for r in rows:
        days = " ".join(f"{d}:{'yes' if ok else 'no '}" for d, ok in r["AvailableOnDay"].items())
        print(f"  {r['Person']}  {r['WorkCenter']:<7}{', '.join(r['SkillTags']):<30}{days}")
    print("\n  No names, no absence types, no pay. People not yet in S/4HANA aren't offered.")


# ------------------------------------------------------------ report
def write_report() -> Path:
    found = findings()
    pay = check_payroll()
    lines = [f"# Calder people-data crossings, {AS_OF}", "",
             "Fictional company and data, made up for the course. Not from an SAP system.", "",
             "```mermaid", "flowchart LR",
             "  S4[S/4HANA CP10] -->|cost centers| HR[HR system]",
             "  HR -->|employees| S4",
             "  HR --> PY[Payroll]",
             "  PY -->|posting document| S4",
             "  TM[Time records] -->|confirmations| S4",
             "  EX[Expense system] -->|postings| S4",
             "```", "",
             "| ID | Crossing | Finding | Owner | Root cause |", "| --- | --- | --- | --- | --- |"]
    lines += [f"| {f[0]} | {f[1]} | {f[2]} | {f[3]} | {f[4]} |" for f in found]
    lines += ["", f"Payroll posting: debits {money(pay['debit'])}, credits {money(pay['credit'])}, "
              f"{'posts' if pay['posts'] else 'held: ' + money(pay['held']) + ' USD'}.", ""]
    out = HERE / "calder_people_crossings.md"
    out.write_text("\n".join(lines) + "\n", encoding="utf-8")
    return out


# ------------------------------------------------------------ sandbox (SAP demo data, not Calder's)
def read_env_key(name: str) -> str:
    value = os.environ.get(name, "")
    env = Path.cwd() / ".env"
    if not value and env.exists():
        for line in env.read_text(encoding="utf-8").splitlines():
            if line.strip().startswith(f"{name}="):
                value = line.split("=", 1)[1].strip().strip('"').strip("'")
    return value


def sandbox() -> None:
    key = read_env_key("SAP_API_KEY")
    if not key:
        sys.exit("SAP_API_KEY is not set. Add it to .env (course setup) or skip this step.")
    base = ("https://sandbox.api.sap.com/s4hanacloud/sap/opu/odata/sap/"
            "API_MANAGE_WORKFORCE_TIMESHEET/TimeSheetEntryCollection")
    # Minimization in practice: no PersonWorkAgreement, no notes. Only what a cost view needs.
    query = urllib.parse.urlencode({"$top": "50", "$format": "json",
                                    "$select": "TimeSheetRecord,CompanyCode,TimeSheetDate,"
                                               "TimeSheetStatus,TimeSheetDataFields"})
    req = urllib.request.Request(f"{base}?{query}", headers={"APIKey": key, "Accept": "application/json"})
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            data = json.loads(resp.read().decode("utf-8"))
    except urllib.error.HTTPError as err:
        sys.exit(f"Sandbox answered HTTP {err.code}. Check the key, or try again later.")
    except (urllib.error.URLError, TimeoutError) as err:
        sys.exit(f"Cannot reach the sandbox ({err}). Check the network or proxy.")
    items = data.get("d", {}).get("results", [])
    by_receiver = {}
    for it in items:
        f = it.get("TimeSheetDataFields") or {}
        receiver = f.get("ReceiverCostCenter") or f.get("WBSElement") or f.get("InternalOrder") or "(none)"
        key2 = (f.get("ActivityType") or "-", receiver)
        by_receiver[key2] = by_receiver.get(key2, 0.0) + float(f.get("RecordedHours") or 0)
    print(f"SAP sandbox: {len(items)} timesheet records read (SAP demo data, not Calder's)\n")
    for (activity, receiver), hours in sorted(by_receiver.items(), key=lambda x: -x[1])[:8]:
        print(f"  activity type {activity:<12} receiver {receiver:<26}{hours:>8.2f} h")
    print("\n  Person fields were not requested: a cost view doesn't need them.")


# ------------------------------------------------------------ main
def main() -> None:
    parser = argparse.ArgumentParser(description="Hire to retire crossings at Calder (fictional data).")
    parser.add_argument("--payroll", action="store_true", help="October payroll posting document")
    parser.add_argument("--time", action="store_true", help="technician time for maintenance orders")
    parser.add_argument("--expenses", action="store_true", help="expense reports waiting to post")
    parser.add_argument("--ai", action="store_true", help="field decisions and the minimized view")
    parser.add_argument("--write", action="store_true", help="write unit1b/calder_people_crossings.md")
    parser.add_argument("--sandbox", action="store_true", help="read timesheet records from SAP's sandbox")
    args = parser.parse_args()
    if args.sandbox:
        sandbox()
        return
    check_pack()
    if args.payroll:
        print_payroll()
    elif args.time:
        print_time()
    elif args.expenses:
        print_expenses()
    elif args.ai:
        print_ai()
    else:
        print_check()
        if args.write:
            print(f"\nwrote unit1b/{write_report().name}")


if __name__ == "__main__":
    main()

Calder Pumpworks (fictional), CP10 people-data crossings on 2026-11-02
HR records: 9   in S/4HANA: 8   findings: 9

  H1  cost centers S/4HANA -> HR  CP11-435 closed in S/4HANA on 2026-09-30, still open in HR (last replicated 2026-09-14); 2 people assigned
      owner: HR integration team               root cause: cost center replication
  H2  employees HR -> S/4HANA     00100231 hired, not in S/4HANA: cost center CP11-435 not valid on 2026-10-19
      owner: HR integration team               root cause: cost center replication
  H3  employees HR -> S/4HANA     00100205 assigned to closed cost center CP11-435
      owner: HR, with the cost accountant      root cause: cost center replication
  H4  leaver -> access            00100094 left on 2026-10-16; S/4HANA business user still valid
      owner: Security administrator            root cause: leaver process
  H5  payroll -> finance          October posting held: 7,350.00 USD on CP11-435
      owner: Payroll, with the G/L accountant  root cause: cost center replication
  H6  time -> maintenance orders  T-5103: 8.0 h by 00100231 on order 4000126 (personnel number not in S/4HANA)
      owner: Maintenance supervisor            root cause: cost center replication
  H7  time -> maintenance orders  T-5104: 6.0 h by 00100231 on order 4000126 (personnel number not in S/4HANA)
      owner: Maintenance supervisor            root cause: cost center replication
  H8  time -> maintenance orders  T-5105: 4.0 h by 00100094 on order 4000126 (date after employment end 2026-10-16)
      owner: Maintenance supervisor            root cause: time entry
  H9  expenses -> finance         ER-2026-0419: 486.75 USD for 00100231 (no employee business partner or supplier role for reimbursement; cost center CP11-435 closed)
      owner: Travel and expense admin          root cause: cost center replication

  By root cause: cost center replication 7, leaver process 1, time entry 1

October payroll posting document for CP10 (fictional), posting date 2026-10-30

  G/L       Account                         Cost center         Debit      Credit  check
  61100000  Wages and salaries              CP11-300        18,400.00              ok
  61200000  Employer payroll taxes          CP11-300         1,410.00              ok
  61100000  Wages and salaries              CP11-410        96,300.00              ok
  61200000  Employer payroll taxes          CP11-410         7,370.00              ok
  61100000  Wages and salaries              CP11-420        31,200.00              ok
  61200000  Employer payroll taxes          CP11-420         2,390.00              ok
  61100000  Wages and salaries              CP11-435         6,830.00              closed
  61200000  Employer payroll taxes          CP11-435           520.00              closed
  61100000  Wages and salaries              CP11-450        38,900.00              ok
  61200000  Employer payroll taxes          CP11-450         2,980.00              ok
  61100000  Wages and salaries              CP11-900        27,600.00              ok
  61200000  Employer payroll taxes          CP11-900         2,110.00              ok
  21500000  Net pay payable                                            158,640.00  
  21600000  Employee withholdings payable                               60,590.00  
  21700000  Employer payroll taxes payable                              16,780.00  

  Debits 236,010.00   credits 236,010.00   balanced
  Result: held. 7,350.00 USD sits on a cost center that is closed in S/4HANA;
  in this scenario the whole document waits, so October payroll is missing from CP10's books.

Technician time for maintenance orders (fictional), October 2026

  T-5101  00100117  2026-10-26  4000126    6.0 h    570.00  confirmed activity allocation to the order
  T-5102  00100142  2026-10-26  4000126    3.5 h    367.50  confirmed activity allocation to the order
  T-5103  00100231  2026-10-27  4000126    8.0 h    760.00  blocked   personnel number not in S/4HANA
  T-5104  00100231  2026-10-28  4000126    6.0 h    570.00  blocked   personnel number not in S/4HANA
  T-5105  00100094  2026-10-20  4000126    4.0 h    380.00  check     date after employment end 2026-10-16

  confirmed   9.5 h    937.50 USD
  blocked    14.0 h  1,330.00 USD
  check       4.0 h    380.00 USD

  Blocked hours are real work missing from the order's cost until the person exists in S/4HANA.

Expense reports waiting to post to CP10 (fictional)

  ER-2026-0412  00100117  CP11-450      642.18  posts   
  ER-2026-0415  00100094  CP11-450    2,318.40  posts   employment ended: keep the supplier role payable until reimbursed
  ER-2026-0419  00100231  CP11-435      486.75  blocked no employee business partner or supplier role for reimbursement; cost center CP11-435 closed

Field decisions for the maintenance scheduling assistant (course policy)

  PersonnelNumber       pseudonymize  needed to join records; the assistant sees a token
  WorkCenter            allow         decides which orders a person can work on
  SkillTags             allow         job-related qualifications
  PlannedWorkingHours   allow         capacity per day
  AvailableOnDay        allow         yes or no per day, derived from absences
  AbsenceType           exclude       can reveal health or family matters; availability is enough
  CostCenter            exclude       not needed to schedule
  PayGrade              exclude       pay data; never needed to schedule
  HomeAddress           exclude       personal data; not needed
  DateOfBirth           exclude       personal data; not needed
  BankAccount           exclude       payment data; not needed

What the assistant receives for the overhaul week, 2 technicians:

  T-dd79bd56  MECH1  hydraulics, crane inspection  11-09:yes 11-10:no  11-11:yes 11-12:yes 11-13:yes
  T-c4b1170a  ELEC1  electrical, PLC               11-09:yes 11-10:yes 11-11:yes 11-12:no  11-13:no 

  No names, no absence types, no pay. People not yet in S/4HANA aren't offered.

SAP sandbox: <n> timesheet records read (SAP demo data, not Calder's)

  activity type <type>        receiver <cost center, WBS or order>      <hours> h

  Person fields were not requested: a cost view doesn't need them.

git add unit1b/hire_to_retire.py unit1b/calder_people_crossings.md
git commit -m "Unit 1B: hire-to-retire crossings check, payroll posting and minimized AI view for Calder"