Bordro işlemleri veri şablonunuz

/* 
ADP Workforce Now does not accept SQL queries from end-users. 
The following configuration block represents the Transformation Logic required to convert the ADP Custom Report export (Wide Format) into the Process Mining Event Log (Long Format).

Input Source: ADP_Custom_Payroll_Export.csv
Logic Language: Pseudo-ETL/Config
*/

TRANSFORMATION_CONFIG {

  GLOBAL_SETTINGS {
    SOURCE_SYSTEM: "ADP Workforce Now"
    CASE_ID_FORMULA: CONCATENATE(Field_AssociateID, "-", Field_PayPeriodNumber, "-", Field_Year)
    LAST_DATA_UPDATE: SYSTEM_TIMESTAMP()
  }

  ACTIVITY_MAPPING_RULES {

    /* 1. Time Sheet Submitted */
    RULE "Time Sheet Submitted" {
      IF Field_Timecard_Submit_Date IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Time Sheet Submitted",
          TIMESTAMP: Field_Timecard_Submit_Date,
          ATTRIBUTES: [PayrollSpecialistName: Field_Timecard_User, IsManualIntervention: "False"]
        )
    }

    /* 2. Time Sheet Approved */
    RULE "Time Sheet Approved" {
      IF Field_Timecard_Approval_Date IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Time Sheet Approved",
          TIMESTAMP: Field_Timecard_Approval_Date,
          ATTRIBUTES: [PayrollSpecialistName: Field_Manager_Name, IsManualIntervention: "True"]
        )
    }

    /* 3. Payroll Record Initialized */
    RULE "Payroll Record Initialized" {
      IF Field_Pay_Period_Start_Date IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Payroll Record Initialized",
          TIMESTAMP: Field_Pay_Period_Start_Date,
          ATTRIBUTES: [PayGroupCode: Field_PayGroup, IsRetrospective: "False"]
        )
    }

    /* 4. Incentive Data Imported */
    RULE "Incentive Data Imported" {
      IF Field_Import_Batch_Date IS NOT NULL AND Field_Batch_Type == "Import" THEN
        CREATE_EVENT(
          ACTIVITY: "Incentive Data Imported",
          TIMESTAMP: Field_Import_Batch_Date,
          ATTRIBUTES: [IsManualIntervention: "False"]
        )
    }

    /* 5. Gross Pay Calculated */
    RULE "Gross Pay Calculated" {
      IF Field_Calc_DateTime IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Gross Pay Calculated",
          TIMESTAMP: Field_Calc_DateTime,
          ATTRIBUTES: [GrossPayAmount: Field_Gross_Pay, DepartmentCode: Field_Home_Dept]
        )
    }

    /* 6. Benefits Deductions Applied */
    RULE "Benefits Deductions Applied" {
      /* Often occurs simultaneous to Calc, adding 1 second for logical sort */
      IF Field_Calc_DateTime IS NOT NULL AND Field_Total_Deductions > 0 THEN
        CREATE_EVENT(
          ACTIVITY: "Benefits Deductions Applied",
          TIMESTAMP: DATE_ADD(Field_Calc_DateTime, 1, "SECOND"),
          ATTRIBUTES: [GrossPayAmount: Field_Gross_Pay]
        )
    }

    /* 7. Audit Exception Flagged */
    RULE "Audit Exception Flagged" {
      IF Field_Error_Message_Timestamp IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Audit Exception Flagged",
          TIMESTAMP: Field_Error_Message_Timestamp,
          ATTRIBUTES: [IsManualIntervention: "False"]
        )
    }

    /* 8. Data Correction Performed */
    RULE "Data Correction Performed" {
      IF Field_Audit_Change_Date IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Data Correction Performed",
          TIMESTAMP: Field_Audit_Change_Date,
          ATTRIBUTES: [PayrollSpecialistName: Field_Audit_User, IsManualIntervention: "True"]
        )
    }

    /* 9. Payroll Result Previewed */
    RULE "Payroll Result Previewed" {
      IF Field_Preview_Run_DateTime IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Payroll Result Previewed",
          TIMESTAMP: Field_Preview_Run_DateTime,
          ATTRIBUTES: [IsManualIntervention: "True"]
        )
    }

    /* 10. Payroll Record Approved */
    RULE "Payroll Record Approved" {
      IF Field_Finalize_DateTime IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Payroll Record Approved",
          TIMESTAMP: Field_Finalize_DateTime,
          ATTRIBUTES: [PayrollSpecialistName: Field_Finalizer_User, IsManualIntervention: "True"]
        )
    }

    /* 11. Bank Transfer File Generated */
    RULE "Bank Transfer File Generated" {
      /* Logic: Usually occurs 2 hours after Finalize or at specific cutoff */
      IF Field_ACH_File_Date IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Bank Transfer File Generated",
          TIMESTAMP: Field_ACH_File_Date,
          ATTRIBUTES: [IsManualIntervention: "False"]
        )
    }

    /* 12. Payment Executed */
    RULE "Payment Executed" {
      IF Field_Check_Date IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Payment Executed",
          TIMESTAMP: Field_Check_Date,
          ATTRIBUTES: [GrossPayAmount: Field_Gross_Pay, IsRetrospective: "False"]
        )
    }

    /* 13. Pay Slip Published */
    RULE "Pay Slip Published" {
      IF Field_Advice_Available_Date IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Pay Slip Published",
          TIMESTAMP: Field_Advice_Available_Date,
          ATTRIBUTES: [IsManualIntervention: "False"]
        )
    }

    /* 14. Tax Filing Completed */
    RULE "Tax Filing Completed" {
      IF Field_Tax_Filing_Confirmation_Date IS NOT NULL THEN
        CREATE_EVENT(
          ACTIVITY: "Tax Filing Completed",
          TIMESTAMP: Field_Tax_Filing_Confirmation_Date,
          ATTRIBUTES: [TaxJurisdictionCode: Field_Tax_State, IsManualIntervention: "False"]
        )
    }

    /* 15. Retrospective Adjustment Posted */
    RULE "Retrospective Adjustment Posted" {
      IF Field_Adjustment_Run_Date IS NOT NULL AND Field_Run_Type == "Adjustment" THEN
        CREATE_EVENT(
          ACTIVITY: "Retrospective Adjustment Posted",
          TIMESTAMP: Field_Adjustment_Run_Date,
          ATTRIBUTES: [IsRetrospective: "True", IsManualIntervention: "True"]
        )
    }
  }
}

import requests
import pandas as pd
import json
from datetime import datetime
import uuid

class=class="hl-string">"hl-comment"># === CONFIGURATION ===
class=class="hl-string">"hl-comment"># Replace these placeholders with your actual ADP credentials and paths
ADP_CLIENT_ID = class="hl-string">"[Your ADP Client ID]"
ADP_CLIENT_SECRET = class="hl-string">"[Your ADP Client Secret]"
CERT_PATH = class="hl-string">"path/to/your/client_certificate.pem"
KEY_PATH = class="hl-string">"path/to/your/client_private_key.key"
TOKEN_URL = class="hl-string">"https://api.adp.com/auth/oauth/v2/token"
PAYROLL_API_URL = class="hl-string">"https://api.adp.com/payroll/v1/payroll-output"
TIME_API_URL = class="hl-string">"https://api.adp.com/time/v1/time-cards"

class=class="hl-string">"hl-comment"># Output File
OUTPUT_FILENAME = class="hl-string">"ADP_Payroll_Event_Log.csv"

class=class="hl-string">"hl-comment"># === AUTHENTICATION ===
def get_access_token():
    class=class="hl-string">"hl-comment"># ADP requires mutual TLS (mTLS) for authentication
    payload = {
        class="hl-string">'client_id': ADP_CLIENT_ID,
        class="hl-string">'client_secret': ADP_CLIENT_SECRET,
        class="hl-string">'grant_type': class="hl-string">'client_credentials'
    }
    try:
        response = requests.post(
            TOKEN_URL,
            data=payload,
            cert=(CERT_PATH, KEY_PATH),
            verify=True
        )
        response.raise_for_status()
        return response.json()[class="hl-string">'access_token']
    except Exception as e:
        print(fclass="hl-string">"Authentication failed: {str(e)}")
        return None

class=class="hl-string">"hl-comment"># === DATA EXTRACTION ===
def fetch_adp_data(url, token, params=None):
    headers = {
        class="hl-string">'Authorization': fclass="hl-string">'Bearer {token}',
        class="hl-string">'Accept': class="hl-string">'application/json'
    }
    all_records = []
    
    class=class="hl-string">"hl-comment"># Simple pagination loop (ADP uses class="hl-string">'skip' and class="hl-string">'top' or class="hl-string">'next' links)
    class=class="hl-string">"hl-comment"># This is a simplified implementation assuming standard offset pagination
    skip = 0
    limit = 50
    fetching = True
    
    while fetching:
        current_params = params.copy() if params else {}
        current_params[class="hl-string">'$skip'] = skip
        current_params[class="hl-string">'$top'] = limit
        
        try:
            response = requests.get(
                url, 
                headers=headers, 
                params=current_params, 
                cert=(CERT_PATH, KEY_PATH)
            )
            if response.status_code != 200:
                break
                
            data = response.json()
            class=class="hl-string">"hl-comment"># Adjust key based on actual API response structure (e.g., class="hl-string">'payrollOutputs', class="hl-string">'timeCards')
            class=class="hl-string">"hl-comment"># Using generic list detection for the script
            key = next((k for k in data.keys() if isinstance(data[k], list)), None)
            
            if not key or len(data[key]) == 0:
                fetching = False
            else:
                all_records.extend(data[key])
                skip += limit
                
        except Exception:
            fetching = False
            
    return all_records

class=class="hl-string">"hl-comment"># === EVENT LOG GENERATION ===
def generate_event_log(payroll_data, time_data):
    event_log = []
    
    class=class="hl-string">"hl-comment"># Index time data by AssociateOID for quick lookup
    time_map = {item.get(class="hl-string">'associateOID'): item for item in time_data}

    for pay_record in payroll_data:
        class=class="hl-string">"hl-comment"># Basic Attributes
        associate_id = pay_record.get(class="hl-string">'associateOID', class="hl-string">'Unknown')
        pay_period_start = pay_record.get(class="hl-string">'payPeriodStartDate', class="hl-string">'')
        class=class="hl-string">"hl-comment"># Create a unique Case ID using AssociateID and Pay Period
        case_id = fclass="hl-string">"{associate_id}-{pay_period_start}"
        
        dept_code = pay_record.get(class="hl-string">'worker', {}).get(class="hl-string">'homeOrganizationalUnits', [{}])[0].get(class="hl-string">'nameCode', {}).get(class="hl-string">'code', class="hl-string">'Unknown')
        pay_group = pay_record.get(class="hl-string">'payrollGroupCode', class="hl-string">'Main')
        gross_pay = pay_record.get(class="hl-string">'grossPayAmount', 0.0)
        tax_jur = pay_record.get(class="hl-string">'taxJurisdiction', {}).get(class="hl-string">'code', class="hl-string">'US')
        last_update = datetime.now().isoformat() class=class="hl-string">"hl-comment"># Using extraction time as fallback if record update time missing

        class=class="hl-string">"hl-comment"># Helper to append event
        def add_event(activity, timestamp, specialist=None, manual=False, retro=False):
            if timestamp:
                event_log.append({
                    class="hl-string">'PayrollRecordId': case_id,
                    class="hl-string">'ActivityName': activity,
                    class="hl-string">'EventDateTime': timestamp,
                    class="hl-string">'SourceSystem': class="hl-string">'ADP Workforce Now',
                    class="hl-string">'LastDataUpdate': last_update,
                    class="hl-string">'PayrollSpecialistName': specialist if specialist else class="hl-string">'System Agent',
                    class="hl-string">'DepartmentCode': dept_code,
                    class="hl-string">'PayGroupCode': pay_group,
                    class="hl-string">'GrossPayAmount': gross_pay,
                    class="hl-string">'TaxJurisdictionCode': tax_jur,
                    class="hl-string">'IsManualIntervention': manual,
                    class="hl-string">'IsRetrospective': retro
                })

        class=class="hl-string">"hl-comment"># --- ACTIVITY 1: Time Sheet Submitted ---
        class=class="hl-string">"hl-comment"># Derived from Time API
        t_card = time_map.get(associate_id)
        if t_card and t_card.get(class="hl-string">'submissionDateTime'):
            add_event(class="hl-string">"Time Sheet Submitted", t_card[class="hl-string">'submissionDateTime'], specialist=t_card.get(class="hl-string">'submittedBy'))

        class=class="hl-string">"hl-comment"># --- ACTIVITY 2: Time Sheet Approved ---
        class=class="hl-string">"hl-comment"># Derived from Time API
        if t_card and t_card.get(class="hl-string">'approvalDateTime'):
            add_event(class="hl-string">"Time Sheet Approved", t_card[class="hl-string">'approvalDateTime'], specialist=t_card.get(class="hl-string">'approvedBy'))

        class=class="hl-string">"hl-comment"># --- ACTIVITY 3: Payroll Record Initialized ---
        class=class="hl-string">"hl-comment"># Creation of the pay data record
        create_time = pay_record.get(class="hl-string">'creationDateTime')
        add_event(class="hl-string">"Payroll Record Initialized", create_time)

        class=class="hl-string">"hl-comment"># --- ACTIVITY 4: Incentive Data Imported ---
        class=class="hl-string">"hl-comment"># Check for specific earnings codes related to incentives
        earnings = pay_record.get(class="hl-string">'earnings', [])
        for earn in earnings:
            if earn.get(class="hl-string">'typeCode') in [class="hl-string">'BONUS', class="hl-string">'COMMISSION']:
                class=class="hl-string">"hl-comment"># Use entry time of the specific line item
                add_event(class="hl-string">"Incentive Data Imported", earn.get(class="hl-string">'entryDateTime', create_time))
                break class=class="hl-string">"hl-comment"># Capture once per case to avoid duplicates or refine logic for multiple

        class=class="hl-string">"hl-comment"># --- ACTIVITY 5: Gross Pay Calculated ---
        class=class="hl-string">"hl-comment"># When the calculation engine finished
        calc_time = pay_record.get(class="hl-string">'calculationDateTime')
        add_event(class="hl-string">"Gross Pay Calculated", calc_time)

        class=class="hl-string">"hl-comment"># --- ACTIVITY 6: Benefits Deductions Applied ---
        class=class="hl-string">"hl-comment"># Usually happens same time as calc, but logically distinct
        class=class="hl-string">"hl-comment"># We look for deduction processing timestamp
        deductions = pay_record.get(class="hl-string">'deductions', [])
        if deductions and calc_time:
             add_event(class="hl-string">"Benefits Deductions Applied", calc_time)

        class=class="hl-string">"hl-comment"># --- ACTIVITY 7: Audit Exception Flagged ---
        class=class="hl-string">"hl-comment"># Check notification messages
        msgs = pay_record.get(class="hl-string">'notificationMessages', [])
        if msgs:
            class=class="hl-string">"hl-comment"># Take the timestamp of the first warning
            add_event(class="hl-string">"Audit Exception Flagged", msgs[0].get(class="hl-string">'generationDateTime', calc_time))

        class=class="hl-string">"hl-comment"># --- ACTIVITY 8: Data Correction Performed ---
        class=class="hl-string">"hl-comment"># Compare modification time vs creation time. If significantly different, assume correction.
        mod_time = pay_record.get(class="hl-string">'modificationDateTime')
        if mod_time and create_time and mod_time > create_time:
            add_event(class="hl-string">"Data Correction Performed", mod_time, manual=True)

        class=class="hl-string">"hl-comment"># --- ACTIVITY 9: Payroll Result Previewed ---
        class=class="hl-string">"hl-comment"># Report generation time
        report_time = pay_record.get(class="hl-string">'reportGenerationDateTime')
        add_event(class="hl-string">"Payroll Result Previewed", report_time)

        class=class="hl-string">"hl-comment"># --- ACTIVITY 10: Payroll Record Approved ---
        class=class="hl-string">"hl-comment"># Final approval timestamp
        approve_time = pay_record.get(class="hl-string">'approvalDateTime')
        add_event(class="hl-string">"Payroll Record Approved", approve_time, specialist=class="hl-string">"Payroll Manager")

        class=class="hl-string">"hl-comment"># --- ACTIVITY 11: Bank Transfer File Generated ---
        class=class="hl-string">"hl-comment"># Distribution file generation
        dist_time = pay_record.get(class="hl-string">'distribution', {}).get(class="hl-string">'fileGenerationDateTime')
        add_event(class="hl-string">"Bank Transfer File Generated", dist_time)

        class=class="hl-string">"hl-comment"># --- ACTIVITY 12: Payment Executed ---
        class=class="hl-string">"hl-comment"># The actual check date or payment date
        pay_date = pay_record.get(class="hl-string">'paymentDate')
        class=class="hl-string">"hl-comment"># Convert date-only string to datetime (assuming 9 AM local)
        if pay_date:
            pay_dt_time = fclass="hl-string">"{pay_date}T09:00:00"
            add_event(class="hl-string">"Payment Executed", pay_dt_time)

        class=class="hl-string">"hl-comment"># --- ACTIVITY 13: Pay Slip Published ---
        class=class="hl-string">"hl-comment"># Usually available on Check Date
        class=class="hl-string">"hl-comment"># Or specific class="hl-string">'publicationDate' if available
        pub_date = pay_record.get(class="hl-string">'payStatementAvailableDateTime')
        if not pub_date and pay_date:
             pub_date = fclass="hl-string">"{pay_date}T08:00:00"
        add_event(class="hl-string">"Pay Slip Published", pub_date)

        class=class="hl-string">"hl-comment"># --- ACTIVITY 14: Tax Filing Completed ---
        class=class="hl-string">"hl-comment"># Tax filing status date
        tax_file_time = pay_record.get(class="hl-string">'taxFiling', {}).get(class="hl-string">'completionDateTime')
        add_event(class="hl-string">"Tax Filing Completed", tax_file_time)

        class=class="hl-string">"hl-comment"># --- ACTIVITY 15: Retrospective Adjustment Posted ---
        class=class="hl-string">"hl-comment"># Check if this record is marked as a retro adjustment
        is_retro = pay_record.get(class="hl-string">'isRetroactive', False)
        if is_retro:
            retro_time = pay_record.get(class="hl-string">'postingDateTime', calc_time)
            add_event(class="hl-string">"Retrospective Adjustment Posted", retro_time, retro=True)

    return pd.DataFrame(event_log)

class=class="hl-string">"hl-comment"># === EXECUTION ===
if __name__ == class="hl-string">"__main__":
    class=class="hl-string">"hl-comment"># 1. Authenticate
    token = get_access_token()
    
    if token:
        class=class="hl-string">"hl-comment"># 2. Fetch Data
        print(class="hl-string">"Fetching Payroll Data...")
        class=class="hl-string">"hl-comment"># Filter for last 90 days - example
        payroll_raw = fetch_adp_data(PAYROLL_API_URL, token)
        
        print(class="hl-string">"Fetching Time Data...")
        time_raw = fetch_adp_data(TIME_API_URL, token)
        
        class=class="hl-string">"hl-comment"># 3. Transform
        print(class="hl-string">"Generating Event Log...")
        df_events = generate_event_log(payroll_raw, time_raw)
        
        class=class="hl-string">"hl-comment"># 4. Export
        if not df_events.empty:
            class=class="hl-string">"hl-comment"># Ensure timestamp format
            df_events[class="hl-string">'EventDateTime'] = pd.to_datetime(df_events[class="hl-string">'EventDateTime']).dt.strftime(class="hl-string">'%Y-%m-%d %H:%M:%S')
            df_events.to_csv(OUTPUT_FILENAME, index=False)
            print(fclass="hl-string">"Success! Event log written to {OUTPUT_FILENAME} with {len(df_events)} rows.")
        else:
            print(class="hl-string">"No events generated.")

WITH
params AS (
    SELECT
        CAST('[Start date parameter]' AS TIMESTAMP) AS start_datetime,
        CAST('[End date parameter]' AS TIMESTAMP) AS end_datetime
),

time_sheet_submitted AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)) AS PayrollRecordId,
        'Time Sheet Submitted' AS ActivityName,
        CAST(t.SubmittedDateTime AS TIMESTAMP) AS EventDateTime,
        'ADP Workforce Now' AS SourceSystem,
        CAST(t.LastDataUpdate AS TIMESTAMP) AS LastDataUpdate,
        CAST(t.PayrollSpecialistName AS VARCHAR(255)) AS PayrollSpecialistName,
        CAST(t.DepartmentCode AS VARCHAR(100)) AS DepartmentCode,
        CAST(t.PayGroupCode AS VARCHAR(100)) AS PayGroupCode,
        CAST(t.GrossPayAmount AS DECIMAL(18,2)) AS GrossPayAmount,
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)) AS TaxJurisdictionCode,
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN) AS IsManualIntervention,
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN) AS IsRetrospective
    FROM [Your time and attendance audit table] t
    CROSS JOIN params p
    WHERE t.SubmittedDateTime >= p.start_datetime
      AND t.SubmittedDateTime < p.end_datetime
      AND t.EventType = 'Time Sheet Submitted'
),

time_sheet_approved AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Time Sheet Approved',
        CAST(t.ApprovedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your time and attendance approval table] t
    CROSS JOIN params p
    WHERE t.ApprovedDateTime >= p.start_datetime
      AND t.ApprovedDateTime < p.end_datetime
      AND t.EventType = 'Time Sheet Approved'
),

payroll_record_initialized AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Payroll Record Initialized',
        CAST(t.PaydataCreatedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your Paydata table] t
    CROSS JOIN params p
    WHERE t.PaydataCreatedDateTime >= p.start_datetime
      AND t.PaydataCreatedDateTime < p.end_datetime
),

incentive_data_imported AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Incentive Data Imported',
        CAST(t.ImportedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your incentive import table] t
    CROSS JOIN params p
    WHERE t.ImportedDateTime >= p.start_datetime
      AND t.ImportedDateTime < p.end_datetime
),

gross_pay_calculated AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Gross Pay Calculated',
        CAST(t.CalculationCompletedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your payroll calculation result table] t
    CROSS JOIN params p
    WHERE t.CalculationCompletedDateTime >= p.start_datetime
      AND t.CalculationCompletedDateTime < p.end_datetime
      AND t.ProcessName = 'Calculate Payroll'
),

benefits_deductions_applied AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Benefits Deductions Applied',
        CAST(t.CalculationCompletedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your payroll deduction result table] t
    CROSS JOIN params p
    WHERE t.CalculationCompletedDateTime >= p.start_datetime
      AND t.CalculationCompletedDateTime < p.end_datetime
      AND t.DeductionCategory IN ('Medical', '401k')
),

audit_exception_flagged AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Audit Exception Flagged',
        CAST(t.ErrorGeneratedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your payroll calculation error table] t
    CROSS JOIN params p
    WHERE t.ErrorGeneratedDateTime >= p.start_datetime
      AND t.ErrorGeneratedDateTime < p.end_datetime
),

data_correction_performed AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Data Correction Performed',
        CAST(t.ChangedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        TRUE,
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your Paydata field level audit table] t
    CROSS JOIN params p
    WHERE t.ChangedDateTime >= p.start_datetime
      AND t.ChangedDateTime < p.end_datetime
      AND t.ChangeSource = 'Paydata Grid'
),

payroll_result_previewed AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Payroll Result Previewed',
        CAST(t.PreviewGeneratedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your payroll preview register table] t
    CROSS JOIN params p
    WHERE t.PreviewGeneratedDateTime >= p.start_datetime
      AND t.PreviewGeneratedDateTime < p.end_datetime
),

payroll_record_approved AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Payroll Record Approved',
        CAST(t.FinalizedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your payroll finalization table] t
    CROSS JOIN params p
    WHERE t.FinalizedDateTime >= p.start_datetime
      AND t.FinalizedDateTime < p.end_datetime
),

bank_transfer_file_generated AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Bank Transfer File Generated',
        CAST(t.FileGeneratedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your bank transfer file table] t
    CROSS JOIN params p
    WHERE t.FileGeneratedDateTime >= p.start_datetime
      AND t.FileGeneratedDateTime < p.end_datetime
),

payment_executed AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Payment Executed',
        CAST(t.PaymentDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your payment execution table] t
    CROSS JOIN params p
    WHERE t.PaymentDateTime >= p.start_datetime
      AND t.PaymentDateTime < p.end_datetime
),

pay_slip_published AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Pay Slip Published',
        CAST(t.PublishedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your pay statement publication table] t
    CROSS JOIN params p
    WHERE t.PublishedDateTime >= p.start_datetime
      AND t.PublishedDateTime < p.end_datetime
),

tax_filing_completed AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Tax Filing Completed',
        CAST(t.FilingCompletedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        CAST(COALESCE(t.IsRetrospective, FALSE) AS BOOLEAN)
    FROM [Your tax filing confirmation table] t
    CROSS JOIN params p
    WHERE t.FilingCompletedDateTime >= p.start_datetime
      AND t.FilingCompletedDateTime < p.end_datetime
),

retrospective_adjustment_posted AS (
    SELECT
        CAST(t.PayrollRecordId AS VARCHAR(255)),
        'Retrospective Adjustment Posted',
        CAST(t.AdjustmentPostedDateTime AS TIMESTAMP),
        'ADP Workforce Now',
        CAST(t.LastDataUpdate AS TIMESTAMP),
        CAST(t.PayrollSpecialistName AS VARCHAR(255)),
        CAST(t.DepartmentCode AS VARCHAR(100)),
        CAST(t.PayGroupCode AS VARCHAR(100)),
        CAST(t.GrossPayAmount AS DECIMAL(18,2)),
        CAST(t.TaxJurisdictionCode AS VARCHAR(100)),
        CAST(COALESCE(t.IsManualIntervention, FALSE) AS BOOLEAN),
        TRUE
    FROM [Your retrospective adjustment table] t
    CROSS JOIN params p
    WHERE t.AdjustmentPostedDateTime >= p.start_datetime
      AND t.AdjustmentPostedDateTime < p.end_datetime
)

SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM time_sheet_submitted
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM time_sheet_approved
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM payroll_record_initialized
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM incentive_data_imported
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM gross_pay_calculated
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM benefits_deductions_applied
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM audit_exception_flagged
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM data_correction_performed
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM payroll_result_previewed
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM payroll_record_approved
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM bank_transfer_file_generated
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM payment_executed
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM pay_slip_published
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM tax_filing_completed
UNION ALL
SELECT PayrollRecordId, ActivityName, EventDateTime, SourceSystem, LastDataUpdate, PayrollSpecialistName, DepartmentCode, PayGroupCode, GrossPayAmount, TaxJurisdictionCode, IsManualIntervention, IsRetrospective FROM retrospective_adjustment_posted
ORDER BY PayrollRecordId, EventDateTime, ActivityName;