Su Template de datos de reclutamiento y adquisición de talento

/*
This is a configuration reference for the Integration Center, not an executable script.
It details the mapping from SAP SuccessFactors OData entities to the target CSV file columns.
Two separate integrations are required and their outputs must be merged.
*/

-- Integration 1: Job Application Events
-- Starting Entity: JobApplicationStatusAuditTrail

-- Field Mappings:
"JobApplication" -> jobApplication/applicationId
"ActivityName" -> [Calculated Field] Based on jobApplication/statusId. Logic:
  CASE jobApplication/statusId:
    WHEN '[Status ID for New Application]' THEN 'Application Received'
    WHEN '[Status ID for Screened]' THEN 'Application Screened'
    WHEN '[Status ID for Phone Screen]' THEN 'Phone Screen Conducted'
    WHEN '[Status ID for Interview Scheduled]' THEN 'Interview Scheduled'
    WHEN '[Status ID for Interview Conducted]' THEN 'Interview Conducted'
    WHEN '[Status ID for Interview Feedback]' THEN 'Feedback Submitted'
    WHEN '[Status ID for Offer Preparation]' THEN 'Offer Details Entered'
    WHEN '[Status ID for Offer Extended]' THEN 'Offer Extended'
    WHEN '[Status ID for Offer Accepted]' THEN 'Offer Accepted'
    WHEN '[Status ID for Background Check]' THEN 'Background Check Initiated'
    WHEN '[Status ID for Onboarding]' THEN 'Onboarding Initiated'
    WHEN '[Status ID for Hired]' THEN 'Candidate Hired'
    WHEN '[Status ID for Rejected]' THEN 'Application Rejected'
    WHEN '[Status ID for Withdrawn]' THEN 'Candidate Withdrew'
    ELSE jobApplication/appStatusSetItem/statusName
  END
"EventTimestamp" -> createdDateTime
"JobRequisitionId" -> jobApplication/jobRequisition/jobReqId
"CandidateId" -> jobApplication/candidate/candidateId
"JobTitle" -> jobApplication/jobRequisition/jobTitle
"Department" -> jobApplication/jobRequisition/department
"Recruiter" -> jobApplication/jobRequisition/recruiter/userId
"HiringManager" -> jobApplication/jobRequisition/hiringManager/userId
"ApplicationStatus" -> jobApplication/appStatusSetItem/statusName
"ApplicationSource" -> jobApplication/source

-- Integration 2: Job Requisition Events
-- Starting Entity: JobRequisition

-- Field Mappings (Row 1 for Job Requisition Created):
"JobApplication" -> jobReqId -- Note: Requisition ID is used as the key here for merging purposes
"ActivityName" -> 'Job Requisition Created'
"EventTimestamp" -> createdDate
"JobRequisitionId" -> jobReqId
"CandidateId" -> NULL
"JobTitle" -> jobTitle
"Department" -> department
"Recruiter" -> recruiter/userId
"HiringManager" -> hiringManager/userId
"ApplicationStatus" -> NULL
"ApplicationSource" -> NULL

-- Field Mappings (Additional rows for Job Posted from a Requisition Audit Trail entity):
-- Note: This requires a third integration starting from the Requisition Status Audit Trail, if available, or a different approach.
-- Assuming a status field on the JobRequisition entity indicates the posting date.
"JobApplication" -> jobReqId
"ActivityName" -> 'Job Posted'
"EventTimestamp" -> [Date field indicating when requisition was posted]
"JobRequisitionId" -> jobReqId
"CandidateId" -> NULL
"JobTitle" -> jobTitle
"Department" -> department
"Recruiter" -> recruiter/userId
"HiringManager" -> hiringManager/userId
"ApplicationStatus" -> NULL
"ApplicationSource" -> NULL

import requests
import pandas as pd
import datetime

# --- Configuration --- #
# Replace with your SuccessFactors API details
API_SERVER_URL = "https://[api_server_url].successfactors.com"
COMPANY_ID = "[Your_Company_ID]"
CLIENT_ID = "[Your_Client_ID]"
CLIENT_SECRET = "[Your_Client_Secret]"

# Date range for the extraction (ISO 8601 format)
START_DATE = "2023-01-01T00:00:00Z"
END_DATE = "2023-12-31T23:59:59Z"

# --- CRITICAL: Customize this mapping for your instance --- #
# Map your specific SuccessFactors status names to the standard activity names
STATUS_TO_ACTIVITY_MAPPING = {
    "Screening": "Application Screened",
    "Phone Screen": "Phone Screen Conducted",
    "Interview": "Interview Conducted",
    "Offer": "Offer Details Entered",
    "Offer Extended": "Offer Extended",
    "Offer Accepted": "Offer Accepted",
    "Background Check": "Background Check Initiated",
    "Ready to Hire": "Onboarding Initiated",
    "Hired": "Candidate Hired",
    "Rejected": "Application Rejected",
    "Withdrawn by candidate": "Candidate Withdrew"
    # Add other status mappings as needed, e.g., 'Interview Scheduled', 'Feedback Submitted'
}

# --- Helper Functions --- #
def get_oauth_token():
    """Authenticates and retrieves an OAuth 2.0 access token."""
    token_url = f"{API_SERVER_URL}/oauth/token"
    payload = {
        "client_id": CLIENT_ID,
        "client_secret": CLIENT_SECRET,
        "grant_type": "client_credentials",
        "company_id": COMPANY_ID
    }
    response = requests.post(token_url, data=payload)
    response.raise_for_status()
    return response.json()["access_token"]

def fetch_all_pages(url, headers):
    """Fetches data from a paginated OData endpoint."""
    results = []
    while url:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        data = response.json()["d"]
        results.extend(data.get("results", [data])) # Handle single vs. multiple results
        url = data.get("__next")
    return results

# --- Main Extraction Logic --- #
def main():
    print("Starting SuccessFactors data extraction...")
    try:
        token = get_oauth_token()
        headers = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
    except requests.exceptions.RequestException as e:
        print(f"Error obtaining OAuth token: {e}")
        return

    event_log = []
    
    # 1. Fetch Job Applications within the date range
    print(f"Fetching job applications created between {START_DATE} and {END_DATE}...")
    job_app_fields = "appStatusSetId,applicationId,source,jobReqId,candidate/candidateId,jobRequisition/jobReqId,jobRequisition/jobTitle,jobRequisition/department,jobRequisition/recruiterUser/defaultFullName,jobRequisition/hiringManagerUser/defaultFullName,jobRequisition/creationDate,jobRequisition/postedDate,creationDate,status/statusName"
    job_app_expand = "candidate,jobRequisition,jobRequisition/recruiterUser,jobRequisition/hiringManagerUser,status"
    job_app_filter = f"creationDate ge datetime'{START_DATE.replace('Z', '')}' and creationDate le datetime'{END_DATE.replace('Z', '')}'"
    job_app_url = f"{API_SERVER_URL}/odata/v2/JobApplication?$format=json&$select={job_app_fields}&$expand={job_app_expand}&$filter={job_app_filter}"

    try:
        applications = fetch_all_pages(job_app_url, headers)
        print(f"Found {len(applications)} applications.")
    except requests.exceptions.RequestException as e:
        print(f"Error fetching job applications: {e}")
        return

    # 2. Process each application and its audit trail
    for i, app in enumerate(applications):
        if (i + 1) % 50 == 0:
            print(f"Processing application {i + 1}/{len(applications)}...")
        
        # Common attributes
        job_req = app.get("jobRequisition", {})
        candidate = app.get("candidate", {})
        
        base_attributes = {
            "JobApplication": app.get("applicationId"),
            "JobRequisitionId": job_req.get("jobReqId"),
            "CandidateId": candidate.get("candidateId"),
            "JobTitle": job_req.get("jobTitle"),
            "Department": job_req.get("department"),
            "Recruiter": job_req.get("recruiterUser", {}).get("defaultFullName"),
            "HiringManager": job_req.get("hiringManagerUser", {}).get("defaultFullName"),
            "ApplicationSource": app.get("source"),
            "ApplicationStatus": app.get("status", {}).get("statusName")
        }

        # Add Requisition and Application creation events
        if job_req.get("creationDate"):
            event_log.append({**base_attributes, "ActivityName": "Job Requisition Created", "EventTimestamp": job_req["creationDate"]})
        if job_req.get("postedDate"): # Note: postedDate might not be enabled
            event_log.append({**base_attributes, "ActivityName": "Job Posted", "EventTimestamp": job_req["postedDate"]})
        if app.get("creationDate"):
            event_log.append({**base_attributes, "ActivityName": "Application Received", "EventTimestamp": app["creationDate"]})
        
        # 3. Fetch Status Audit Trail for the current application
        audit_trail_url = f"{API_SERVER_URL}/odata/v2/JobApplication({app['applicationId']}L)/appStatusTrail?$format=json"
        try:
            audit_trail_items = fetch_all_pages(audit_trail_url, headers)
            for item in audit_trail_items:
                status_name = item.get("statusName")
                if status_name in STATUS_TO_ACTIVITY_MAPPING:
                    activity_name = STATUS_TO_ACTIVITY_MAPPING[status_name]
                    event_log.append({**base_attributes, "ActivityName": activity_name, "EventTimestamp": item.get("createdDate")})
        except requests.exceptions.RequestException as e:
            print(f"Could not fetch audit trail for application {app['applicationId']}: {e}")
            continue

    # 4. Create and save DataFrame
    if not event_log:
        print("No events were generated. Check your date range and status mappings.")
        return
    
    df = pd.DataFrame(event_log)
    # Reorder columns for clarity
    cols = ["JobApplication", "ActivityName", "EventTimestamp", "JobRequisitionId", "CandidateId", "JobTitle", 
            "Department", "Recruiter", "HiringManager", "ApplicationStatus", "ApplicationSource"]
    df = df[cols]
    
    # Convert timestamp format
    df['EventTimestamp'] = pd.to_datetime(df['EventTimestamp'], format='/Date(%f%z)/')
    df = df.sort_values(by=["JobApplication", "EventTimestamp"])

    output_filename = 'sfsf_recruiting_event_log.csv'
    df.to_csv(output_filename, index=False)
    print(f"Extraction complete. Event log saved to {output_filename}")

if __name__ == "__main__":
    main()

import requests
import pandas as pd
import json
from datetime import datetime, timedelta
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
import base64
import time

class=class="hl-string">"hl-comment"># --- CONFIGURATION SECTION --- 
class=class="hl-string">"hl-comment"># Replace with your SAP SuccessFactors API details
SF_API_CENTER_URL = class="hl-string">"[Your SuccessFactors API Server URL, e.g., https://apiX.successfactors.com]"
SF_COMPANY_ID = class="hl-string">"[Your Company ID]"
SF_CLIENT_ID = class="hl-string">"[Your OAuth Client ID / API Key]"
SF_USER_ID = class="hl-string">"[Your API User ID]"
SF_PRIVATE_KEY_PATH = class="hl-string">"[Path to your private key .pem file]"

class=class="hl-string">"hl-comment"># Date range for the extraction (YYYY-MM-DD format)
START_DATE = class="hl-string">"2023-01-01"
END_DATE = class="hl-string">"2023-12-31"

class=class="hl-string">"hl-comment"># Page size for API calls
PAGE_SIZE = 1000

class=class="hl-string">"hl-comment"># CRITICAL: Map your specific SF status names to standard activity names.
class=class="hl-string">"hl-comment"># Work with an SF admin to get the exact status names from your instance.
STATUS_TO_ACTIVITY_MAPPING = {
    class="hl-string">"New Application": class="hl-string">"Application Received",
    class="hl-string">"Screen": class="hl-string">"Application Screened",
    class="hl-string">"Phone Screen": class="hl-string">"Phone Screen Conducted",
    class="hl-string">"Interview": class="hl-string">"Interview Conducted",
    class="hl-string">"Offer": class="hl-string">"Offer Details Entered",
    class="hl-string">"Offer Extended": class="hl-string">"Offer Extended",
    class="hl-string">"Offer Accepted": class="hl-string">"Offer Accepted",
    class="hl-string">"Background Check": class="hl-string">"Background Check Initiated",
    class="hl-string">"Ready to Hire": class="hl-string">"Onboarding Initiated",
    class="hl-string">"Hired": class="hl-string">"Candidate Hired",
    class="hl-string">"Rejected": class="hl-string">"Application Rejected",
    class="hl-string">"Withdrawn by Candidate": class="hl-string">"Candidate Withdrew"
    class=class="hl-string">"hl-comment"># Add other custom statuses here, e.g.:
    class=class="hl-string">"hl-comment"># class="hl-string">"Interview Scheduled": class="hl-string">"Interview Scheduled",
    class=class="hl-string">"hl-comment"># class="hl-string">"Interviewer Feedback Submitted": class="hl-string">"Feedback Submitted"
}

def get_access_token():
    class="hl-string">"""Generates a JWT and exchanges it for an OAuth 2.0 access token."""
    try:
        with open(SF_PRIVATE_KEY_PATH, class="hl-string">"rb") as key_file:
            private_key = serialization.load_pem_private_key(
                key_file.read(),
                password=None,
            )
    except Exception as e:
        print(fclass="hl-string">"Error reading private key: {e}")
        return None

    class=class="hl-string">"hl-comment"># Create assertion
    assertion_payload = {
        class="hl-string">"iss": SF_CLIENT_ID,
        class="hl-string">"sub": SF_USER_ID,
        class="hl-string">"aud": class="hl-string">"www.successfactors.com",
        class="hl-string">"exp": int(time.time()) + 300 class=class="hl-string">"hl-comment"># 5 minute expiry
    }
    
    class=class="hl-string">"hl-comment"># This part requires the class="hl-string">'PyJWT' library if you want to create a JWT.
    class=class="hl-string">"hl-comment"># For simplicity, we assume the user might use a different library or method.
    class=class="hl-string">"hl-comment"># As a fallback, this example shows a conceptual SAML assertion structure.
    class=class="hl-string">"hl-comment"># In a real scenario, a library like `PyJWT` or `Authlib` would be used.
    class=class="hl-string">"hl-comment"># We'll use a simplified placeholder for the assertion generation logic.
    class=class="hl-string">"hl-comment"># For this example to work, you'd need to implement proper JWT signing.
    class=class="hl-string">"hl-comment"># The below is a placeholder and will not work without a signing library.
    class=class="hl-string">"hl-comment"># Weclass="hl-string">'ll mock the assertion for this script's structure.
    
    class=class="hl-string">"hl-comment"># For a real implementation, you would use a library to sign the assertion.
    class=class="hl-string">"hl-comment"># Let's assume we have a signed assertion string.
    class=class="hl-string">"hl-comment"># For this example, we'll proceed as if `signed_assertion` is correctly generated.
    class=class="hl-string">"hl-comment"># signed_assertion = jwt.encode(assertion_payload, private_key, algorithm=class="hl-string">'RS256')
    class=class="hl-string">"hl-comment"># Since we can't sign it here without more libraries, we will skip to the request part.

    token_url = fclass="hl-string">"{SF_API_CENTER_URL}/oauth/token"
    headers = {class="hl-string">"Content-Type": class="hl-string">"application/x-www-form-urlencoded"}
    
    class=class="hl-string">"hl-comment"># The grant_type must be urn:ietf:params:oauth:grant-type:saml2-bearer
    class=class="hl-string">"hl-comment"># You would need to URL-encode a properly signed SAML or JWT assertion.
    class=class="hl-string">"hl-comment"># This step is highly dependent on your specific SF setup (SAML vs JWT assertion).
    class=class="hl-string">"hl-comment"># We will simulate the request conceptually.
    print(class="hl-string">"Requesting access token. Note: Assertion signing is required for a live environment.")
    
    class=class="hl-string">"hl-comment"># This is a simplified payload. A real assertion is needed for the `assertion` field.
    class=class="hl-string">"hl-comment"># You must generate this assertion and sign it with your private key.
    payload = {
        class="hl-string">'grant_type': class="hl-string">'urn:ietf:params:oauth:grant-type:saml2-bearer',
        class="hl-string">'company_id': SF_COMPANY_ID,
        class="hl-string">'client_id': SF_CLIENT_ID,
        class="hl-string">'assertion': class="hl-string">'[A correctly signed SAML/JWT assertion goes here]'
    }

    class=class="hl-string">"hl-comment"># A note to the user that this part needs to be implemented.
    print(class="hl-string">"\n*** ACTION REQUIRED ***")
    print(class="hl-string">"The following API call for an access token is a placeholder.")
    print(class="hl-string">"You must replace the 'assertion' value with a real, signed SAML/JWT assertion.")
    print(class="hl-string">"See SAP SuccessFactors documentation for OAuth 2.0 authentication.")
    print(class="hl-string">"**********************\n")
    
    class=class="hl-string">"hl-comment"># As we cannot generate a real token here, we return a placeholder.
    class=class="hl-string">"hl-comment"># In your real script, you would make the request and return the token.
    class=class="hl-string">"hl-comment"># response = requests.post(token_url, headers=headers, data=payload)
    class=class="hl-string">"hl-comment"># if response.status_code == 200:
    class=class="hl-string">"hl-comment">#     return response.json().get(class="hl-string">'access_token')
    class=class="hl-string">"hl-comment"># else:
    class=class="hl-string">"hl-comment">#     print(fclass="hl-string">"Error getting token: {response.status_code} {response.text}")
    class=class="hl-string">"hl-comment">#     return None
    return class="hl-string">"[Your_Generated_Access_Token]" class=class="hl-string">"hl-comment"># Replace this with the actual token retrieval logic


def fetch_all_pages(url, headers):
    class="hl-string">"""Fetches all pages of data from a paginated OData endpoint."""
    all_results = []
    while url:
        try:
            response = requests.get(url, headers=headers)
            response.raise_for_status()
            data = response.json()
            all_results.extend(data.get(class="hl-string">'d', {}).get(class="hl-string">'results', []))
            class=class="hl-string">"hl-comment"># SuccessFactors uses __next for the next page link
            url = data.get(class="hl-string">'d', {}).get(class="hl-string">'__next', None)
            if url:
                print(fclass="hl-string">"Fetching next page...")
        except requests.exceptions.RequestException as e:
            print(fclass="hl-string">"API request failed: {e}")
            break
    return all_results

def main():
    class="hl-string">"""Main function to extract, transform, and save the data."""
    access_token = get_access_token()
    if not access_token or access_token == class="hl-string">"[Your_Generated_Access_Token]":
        print(class="hl-string">"Could not obtain access token. Please check your configuration and assertion logic.")
        return

    headers = {
        class="hl-string">"Authorization": fclass="hl-string">"Bearer {access_token}",
        class="hl-string">"Accept": class="hl-string">"application/json"
    }

    class=class="hl-string">"hl-comment"># 1. Fetch Job Requisition Data for class="hl-string">'Created' and class="hl-string">'Posted' events
    print(class="hl-string">"Fetching Job Requisition data...")
    req_filter = fclass="hl-string">"createdDate ge datetime'{START_DATE}T00:00:00Z' and createdDate le datetime'{END_DATE}T23:59:59Z'"
    req_url = fclass="hl-string">"{SF_API_CENTER_URL}/odata/v2/JobRequisition?$format=json&$filter={req_filter}&$select=jobReqId,createdDateTime,jobTitle,department,recruiter/userId,recruiter/defaultFullName,hiringManager/userId,hiringManager/defaultFullName,status&$expand=recruiter,hiringManager&$top={PAGE_SIZE}"
    requisitions_data = fetch_all_pages(req_url, headers)
    
    req_events = []
    for req in requisitions_data:
        class=class="hl-string">"hl-comment"># Event: Job Requisition Created
        req_events.append({
            class="hl-string">'JobApplication': fclass="hl-string">"REQ-{req['jobReqId']}",  class=class="hl-string">"hl-comment"># Use req id as case for these events
            class="hl-string">'ActivityName': class="hl-string">'Job Requisition Created',
            class="hl-string">'EventTimestamp': req[class="hl-string">'createdDateTime'],
            class="hl-string">'JobRequisitionId': req[class="hl-string">'jobReqId'],
            class="hl-string">'CandidateId': None,
            class="hl-string">'JobTitle': req[class="hl-string">'jobTitle'],
            class="hl-string">'Department': req.get(class="hl-string">'department'),
            class="hl-string">'Recruiter': req.get(class="hl-string">'recruiter', {}).get(class="hl-string">'defaultFullName'),
            class="hl-string">'HiringManager': req.get(class="hl-string">'hiringManager', {}).get(class="hl-string">'defaultFullName'),
            class="hl-string">'ApplicationStatus': req[class="hl-string">'status'],
            class="hl-string">'ApplicationSource': None
        })
        class=class="hl-string">"hl-comment"># Event: Job Posted (inferred from status, this may need adjustment)
        if req[class="hl-string">'status'] == class="hl-string">'Posted': class=class="hl-string">"hl-comment"># This status name is an assumption
            req_events.append({
                class="hl-string">'JobApplication': fclass="hl-string">"REQ-{req['jobReqId']}",
                class="hl-string">'ActivityName': class="hl-string">'Job Posted',
                 class=class="hl-string">"hl-comment"># Using createdDateTime as a proxy; lastModifiedDateTime would be better if available
                class="hl-string">'EventTimestamp': req[class="hl-string">'createdDateTime'], 
                class="hl-string">'JobRequisitionId': req[class="hl-string">'jobReqId'],
                class="hl-string">'CandidateId': None,
                class="hl-string">'JobTitle': req[class="hl-string">'jobTitle'],
                class="hl-string">'Department': req.get(class="hl-string">'department'),
                class="hl-string">'Recruiter': req.get(class="hl-string">'recruiter', {}).get(class="hl-string">'defaultFullName'),
                class="hl-string">'HiringManager': req.get(class="hl-string">'hiringManager', {}).get(class="hl-string">'defaultFullName'),
                class="hl-string">'ApplicationStatus': req[class="hl-string">'status'],
                class="hl-string">'ApplicationSource': None
            })

    df_req_events = pd.DataFrame(req_events)
    print(fclass="hl-string">"Processed {len(df_req_events)} job requisition events.")

    class=class="hl-string">"hl-comment"># 2. Fetch Job Application Status Audit Trail Data
    print(class="hl-string">"\nFetching Job Application status audit trail data...")
    audit_filter = fclass="hl-string">"createdDate ge datetime'{START_DATE}T00:00:00Z' and createdDate le datetime'{END_DATE}T23:59:59Z'"
    audit_select = class="hl-string">"jobApplication/appId,jobApplication/jobReqId,jobApplication/candidate/candidateId,jobApplication/source,jobApplication/status,jobApplication/jobRequisition/jobTitle,jobApplication/jobRequisition/department,jobApplication/jobRequisition/recruiter/defaultFullName,jobApplication/jobRequisition/hiringManager/defaultFullName,status,createdDate"
    audit_expand = class="hl-string">"jobApplication,jobApplication/candidate,jobApplication/jobRequisition,jobApplication/jobRequisition/recruiter,jobApplication/jobRequisition/hiringManager"
    audit_url = fclass="hl-string">"{SF_API_CENTER_URL}/odata/v2/JobApplicationStatusAuditTrail?$format=json&$filter={audit_filter}&$select={audit_select}&$expand={audit_expand}&$top={PAGE_SIZE}"
    
    audit_data = fetch_all_pages(audit_url, headers)
    
    app_events = []
    for item in audit_data:
        app_info = item.get(class="hl-string">'jobApplication')
        if not app_info: continue

        activity_name = STATUS_TO_ACTIVITY_MAPPING.get(item.get(class="hl-string">'status'), None)
        if not activity_name: continue class=class="hl-string">"hl-comment"># Skip statuses not in our mapping

        app_events.append({
            class="hl-string">'JobApplication': app_info.get(class="hl-string">'appId'),
            class="hl-string">'ActivityName': activity_name,
            class="hl-string">'EventTimestamp': item.get(class="hl-string">'createdDate'),
            class="hl-string">'JobRequisitionId': app_info.get(class="hl-string">'jobReqId'),
            class="hl-string">'CandidateId': app_info.get(class="hl-string">'candidate', {}).get(class="hl-string">'candidateId'),
            class="hl-string">'JobTitle': app_info.get(class="hl-string">'jobRequisition', {}).get(class="hl-string">'jobTitle'),
            class="hl-string">'Department': app_info.get(class="hl-string">'jobRequisition', {}).get(class="hl-string">'department'),
            class="hl-string">'Recruiter': app_info.get(class="hl-string">'jobRequisition', {}).get(class="hl-string">'recruiter', {}).get(class="hl-string">'defaultFullName'),
            class="hl-string">'HiringManager': app_info.get(class="hl-string">'jobRequisition', {}).get(class="hl-string">'hiringManager', {}).get(class="hl-string">'defaultFullName'),
            class="hl-string">'ApplicationStatus': app_info.get(class="hl-string">'status'),
            class="hl-string">'ApplicationSource': app_info.get(class="hl-string">'source')
        })

    df_app_events = pd.DataFrame(app_events)
    print(fclass="hl-string">"Processed {len(df_app_events)} application status events.")

    class=class="hl-string">"hl-comment"># 3. Combine, Clean, and Export
    if df_app_events.empty and df_req_events.empty:
        print(class="hl-string">"No data extracted. Please check your date range and API permissions.")
        return

    final_df = pd.concat([df_req_events, df_app_events], ignore_index=True)
    final_df = final_df.sort_values(by=[class="hl-string">'JobApplication', class="hl-string">'EventTimestamp']).reset_index(drop=True)
    
    class=class="hl-string">"hl-comment"># Convert timestamp string to datetime object and format it
    class=class="hl-string">"hl-comment"># Example SF format: /Date(1672531200000+0000)/
    final_df[class="hl-string">'EventTimestamp'] = pd.to_datetime(final_df[class="hl-string">'EventTimestamp'].str.extract(rclass="hl-string">'(\d+)')[0], unit=class="hl-string">'ms')
    final_df[class="hl-string">'EventTimestamp'] = final_df[class="hl-string">'EventTimestamp'].dt.strftime(class="hl-string">'%Y-%m-%d %H:%M:%S')

    class=class="hl-string">"hl-comment"># Rename columns for ProcessMind
    final_df.rename(columns={class="hl-string">'JobRequisitionId': class="hl-string">'Job Requisition ID'}, inplace=True)

    output_filename = class="hl-string">'sfsf_recruiting_event_log.csv'
    final_df.to_csv(output_filename, index=False, encoding=class="hl-string">'utf-8')
    print(fclass="hl-string">"\nExtraction complete. Event log saved to {output_filename}")

if __name__ == class="hl-string">"__main__":
    main()