app/jobs/reach.py derives each board's reach once per pull and the pull hands it to the runner through the batch payload. SmartRecruiters, Eightfold and SuccessFactors filter one country a request, Phenom a list, Workday and Oracle by host ids from facets. Remote beside countries is a series of its own, since two facets intersect. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
248 lines
11 KiB
Python
248 lines
11 KiB
Python
"""Oracle Recruiting Cloud: `oracle:<host>/<siteNumber>`, for example
|
|
`oracle:fa-ewto-saasfaprod1.fa.ocs.oraclecloud.com/CX_1001`. A paged REST
|
|
listing that states its total, and a per-role resource for the description.
|
|
|
|
The host is the tenant's Fusion pod (`fa-...ocs.oraclecloud.com`), not the
|
|
company's own domain: Nokia's `jobs.nokia.com` only redirects to it. The site
|
|
number is `CX_1001` or `CX_1` on the tenants read so far, and the site's own
|
|
name (`SinchCareer`) is taken in its place. Written from live boards on
|
|
2026-09-29 (Milestone Systems, Nokia, Danske Bank, Sinch); jobhunt-hq did not
|
|
read Oracle.
|
|
|
|
Countries are filtered on the server by `selectedLocationsFacet`, the pod's
|
|
geography ids (`Filters(country="ids")`), which `facets` reads off
|
|
`locationsFacet`; several ids go in one request, joined with `;`, the way the
|
|
site's own search sends a multiple choice. That list holds only the pod's ten
|
|
biggest countries (fa-evmr's, 2026-09-30), so when it is full a country
|
|
missing from it may still have roles: `facets` then maps every other country
|
|
to `*`, and a series asking for one is read without a country filter. An id
|
|
the pod does not know answers the whole board (review). Remote is
|
|
`selectedWorkplaceTypesFacet=ORA_REMOTE` (`remote="one"`); two facets are an
|
|
intersection (Finland and remote answered 0 on 2026-09-30), which is why the
|
|
runner asks for remote in a series of its own.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import html
|
|
import json
|
|
import re
|
|
from collections.abc import Callable
|
|
from typing import Any
|
|
from urllib.parse import quote
|
|
|
|
from desk.sources import strip_html
|
|
|
|
from ._contract import Ask, Fields, Filters, Place, Reads
|
|
from ._countries import NAMES, code_of
|
|
from ._shared import Get, Page, Row, only, parse_dt
|
|
|
|
NAME = "oracle"
|
|
LABEL = "Oracle Recruiting Cloud"
|
|
KEEP_CASE = True
|
|
PATTERNS = (
|
|
# The candidate site or one role's page: `<pod>/hcmUI/CandidateExperience/en/sites/CX_1/jobs`.
|
|
r"https?://([a-z0-9-]+(?:\.[a-z0-9-]+)*\.oraclecloud\.(?:com|eu))"
|
|
r"/hcmUI/CandidateExperience/[A-Za-z_-]+/sites/([A-Za-z0-9_-]+)",
|
|
# The REST call a company's own page makes, which names the site as `siteNumber=`.
|
|
r"https?://([a-z0-9-]+(?:\.[a-z0-9-]+)*\.oraclecloud\.(?:com|eu))"
|
|
r"/hcmRestApi/resources/[a-z0-9.]+/recruitingCEJobRequisitions[^\"'\s]*?siteNumber=([A-Za-z0-9_-]+)",
|
|
# No slug: another page of a tenant's Fusion UI (its sign-in, say), which names
|
|
# the host but no candidate site.
|
|
r"oraclecloud\.(?:com|eu)/hcmUI(?!/CandidateExperience/[A-Za-z_-]+/sites/)",
|
|
)
|
|
|
|
READS = Reads(
|
|
scope="board", listing="paged", page_size=200, text="detail", teaser=True,
|
|
complete="stated", places="many", filters=Filters(country="ids", remote="one"),
|
|
fields=Fields(posted="trusted", remote="stated", country="stated"),
|
|
robots=("read: robots.txt allows /hcmUI/CandidateExperience/en/sites/<site>/jobs "
|
|
"(checked 2026-09-29)"),
|
|
)
|
|
|
|
#: The page size asked for. 200 was answered in full by Nokia (600 roles in
|
|
#: three calls of about 360 KB, 2026-09-29); the cursor advances by what a page
|
|
#: returned, so a tenant that caps `limit` lower would not skip a role.
|
|
PAGE_SIZE = 200
|
|
|
|
#: A pod: `fa-ewto-saasfaprod1.fa.ocs.oraclecloud.com`. Oracle's regions also
|
|
#: use `.eu` (Danske Bank's `ejqi.fa.ocs.oraclecloud.eu`). A host name has no
|
|
#: case, so a slug written with capitals is allowed as its lowercase.
|
|
_HOST = r"[a-z0-9-]+(?:\.[a-z0-9-]+)*\.oraclecloud\.(?:com|eu)"
|
|
_SLUG = re.compile(rf"({_HOST})/([A-Za-z0-9_-]+)", re.IGNORECASE)
|
|
|
|
#: `WorkplaceTypeCode` -> `store._remote`'s words. A role that states none
|
|
#: has an empty code, which stays unknown.
|
|
_REMOTE = {"ora_remote": "remote", "ora_hybrid": "hybrid", "ora_on_site": "onsite"}
|
|
|
|
|
|
def _parts(slug: str) -> tuple[str, str]:
|
|
"""`(host, site number)` of a slug that passed `slug_ok`."""
|
|
host, _, site = slug.partition("/")
|
|
return host.lower(), site
|
|
|
|
|
|
def slug_ok(slug: str) -> bool:
|
|
return bool(_SLUG.fullmatch(slug))
|
|
|
|
|
|
def allowed(slug: str) -> Callable[[str], bool]:
|
|
return only(_parts(slug)[0])
|
|
|
|
|
|
def _base(slug: str) -> str:
|
|
host, site = _parts(slug)
|
|
return f"https://{host}/hcmUI/CandidateExperience/en/sites/{site}"
|
|
|
|
|
|
def careers_url(slug: str) -> str:
|
|
return f"{_base(slug)}/jobs"
|
|
|
|
|
|
def _api(slug: str) -> str:
|
|
return f"https://{_parts(slug)[0]}/hcmRestApi/resources/latest"
|
|
|
|
|
|
def page(get: Get, slug: str, cursor: Any, ask: Ask = Ask()) -> Page:
|
|
"""One page of `recruitingCEJobRequisitions`. The answer's outer `count`,
|
|
`hasMore` and `limit` describe the one search wrapper in `items`, so the
|
|
total (`TotalJobsCount`) and the roles (`requisitionList`) are read from
|
|
`items[0]`. Without the `expand` only the facets come back; asking for
|
|
`requisitionList.secondaryLocations` gives the roles and each one's other
|
|
locations, which the plain `requisitionList` leaves out. Past the last role
|
|
the list is empty."""
|
|
offset = int(cursor or 0)
|
|
site = _parts(slug)[1]
|
|
data = json.loads(get(
|
|
f"{_api(slug)}/recruitingCEJobRequisitions?onlyData=true"
|
|
f"&expand=requisitionList.secondaryLocations"
|
|
f"&finder=findReqs;siteNumber={site},{_selected(ask)}limit={PAGE_SIZE},offset={offset}"))
|
|
search = (data.get("items") or [{}])[0]
|
|
roles = search.get("requisitionList") or []
|
|
# `_paged` counts `id`, which Oracle spells `Id`.
|
|
results = [{"id": str(role.get("Id") or "")} for role in roles]
|
|
return search, results, search.get("TotalJobsCount"), offset + len(roles) if roles else None
|
|
|
|
|
|
#: How many countries `locationsFacet` lists at most; a list this long may
|
|
#: leave some out.
|
|
FACET_LIMIT = 10
|
|
|
|
|
|
def _selected(ask: Ask) -> str:
|
|
"""The finder's facet parameters for `ask`, each ending in a comma: the
|
|
location ids (none when one is `*`, a country the pod did not list) and
|
|
remote."""
|
|
out = ""
|
|
ids = [i for i in ask.countries if re.fullmatch(r"\d+", i)]
|
|
if ids and "*" not in ask.countries:
|
|
out += f"selectedLocationsFacet={'%3B'.join(ids)},"
|
|
if ask.remote:
|
|
out += "selectedWorkplaceTypesFacet=ORA_REMOTE,"
|
|
return out
|
|
|
|
|
|
def facets(get: Get, slug: str) -> dict[str, dict[str, str]]:
|
|
"""The pod's geography id of each country `locationsFacet` names, read
|
|
with the facets and no roles. When the list is `FACET_LIMIT` long, every
|
|
country it leaves out maps to `*`: its roles may be there, and a read
|
|
for it goes unfiltered."""
|
|
site = _parts(slug)[1]
|
|
data = json.loads(get(
|
|
f"{_api(slug)}/recruitingCEJobRequisitions?onlyData=true"
|
|
f"&finder=findReqs;siteNumber={site},facetsList=LOCATIONS,limit=1,offset=0"))
|
|
listed = (data.get("items") or [{}])[0].get("locationsFacet") or []
|
|
country = {code: str(entry["Id"]) for entry in listed
|
|
if isinstance(entry, dict) and entry.get("Id")
|
|
and (code := code_of(str(entry.get("Name") or "")))}
|
|
if len(listed) >= FACET_LIMIT:
|
|
country = dict.fromkeys(NAMES, "*") | country
|
|
return {"country": country}
|
|
|
|
|
|
def parse(body: bytes, slug: str) -> list[Row]:
|
|
return rows((json.loads(body).get("items") or [{}])[0], slug)
|
|
|
|
|
|
def _text(value: Any) -> str:
|
|
return value.strip() if isinstance(value, str) else ""
|
|
|
|
|
|
def _plain(value: Any) -> str:
|
|
"""Plain text from a field of HTML, entities (`&`, ` `) included."""
|
|
return html.unescape(strip_html(_text(value))).replace("\xa0", " ").strip()
|
|
|
|
|
|
def rows(search: dict[str, Any], slug: str) -> list[Row]:
|
|
"""The roles of one page's search wrapper. The list carries the title, the
|
|
id, `PostedDate` (a date), `PrimaryLocation` ("Copenhagen, Denmark"; a
|
|
country alone where the role names no city), `secondaryLocations`,
|
|
`WorkplaceTypeCode` and `ShortDescriptionStr`, one paragraph that Nokia
|
|
and Milestone fill for most roles. The department fields (`JobFamily`,
|
|
`Department`, `Organization`) were null on every role of all four boards
|
|
read, and are taken when a tenant fills them. The full description is in
|
|
the role's own resource, see `detail`. No pay is stated."""
|
|
out = []
|
|
for role in search.get("requisitionList") or []:
|
|
role_id = str(role.get("Id") or "").strip()
|
|
title = _text(role.get("Title"))
|
|
# The id goes into a URL, and a listing is external content.
|
|
if not title or not re.fullmatch(r"[A-Za-z0-9_-]+", role_id):
|
|
continue
|
|
remote = _REMOTE.get(_text(role.get("WorkplaceTypeCode")).lower())
|
|
places: list[Place] = []
|
|
codes: set[str] = set()
|
|
secondary = [s for s in role.get("secondaryLocations") or [] if isinstance(s, dict)]
|
|
for name, code in ((_text(role.get("PrimaryLocation")),
|
|
_text(role.get("PrimaryLocationCountry"))),
|
|
*((_text(s.get("Name")), _text(s.get("CountryCode")))
|
|
for s in secondary)):
|
|
if name and name not in (p["text"] for p in places):
|
|
places.append({"text": name, "remote": {"remote": True, "hybrid": False,
|
|
"onsite": False}.get(remote or "")})
|
|
if code:
|
|
codes.add(code.upper())
|
|
out.append({
|
|
"source_id": role_id,
|
|
"title": title,
|
|
"places": places,
|
|
"location": "; ".join(p["text"] for p in places),
|
|
"url": f"{_base(slug)}/job/{role_id}",
|
|
"posted": parse_dt(role.get("PostedDate")),
|
|
"department": (_text(role.get("JobFamily")) or _text(role.get("JobFunction"))
|
|
or _text(role.get("Department")) or _text(role.get("Organization"))),
|
|
"description": "",
|
|
"teaser": _plain(role.get("ShortDescriptionStr")),
|
|
"country": next(iter(codes)) if len(codes) == 1 else None,
|
|
"remote": remote,
|
|
"salary_text": "", # the resource states no pay
|
|
})
|
|
return out
|
|
|
|
|
|
def detail(get: Get, slug: str, row: Row) -> dict[str, Any]:
|
|
"""The role's own resource (`recruitingCEJobRequisitionDetails`, found by
|
|
`Id` and site). Only here is the full text: `ExternalDescriptionStr`, with
|
|
the responsibilities and qualifications strings after it where a tenant
|
|
fills them (Milestone leaves them empty), all HTML. `ExternalPostedStartDate`
|
|
is a timestamp where the listing has a date. A role that is no longer open
|
|
answers 200 with no items, and has nothing to read."""
|
|
site = _parts(slug)[1]
|
|
role_id = quote(str(row["source_id"]), safe="")
|
|
data = json.loads(get(
|
|
f"{_api(slug)}/recruitingCEJobRequisitionDetails?expand=all&onlyData=true"
|
|
f"&finder=ById;Id=%22{role_id}%22,siteNumber={site}"))
|
|
items = data.get("items") or []
|
|
if not items:
|
|
return {}
|
|
role = items[0]
|
|
text = " ".join(part for key in ("ExternalDescriptionStr", "ExternalResponsibilitiesStr",
|
|
"ExternalQualificationsStr")
|
|
if (part := _plain(role.get(key))))
|
|
out: dict[str, Any] = {}
|
|
if text:
|
|
out["description"] = text
|
|
if posted := parse_dt(role.get("ExternalPostedStartDate")):
|
|
out["posted"] = posted
|
|
return out
|