数据模板：应付账款发票处理

NetSuite

← 返回改进指南

应付账款发票处理属性 (22) 应付账款发票处理活动 (14) 提取指南 (4)

您的应付账款发票处理数据模板

这份综合模板旨在指导您收集优化应付账款发票处理流程所需的数据。它概述了需要收集的基本属性及要在事件日志中跟踪的关键活动。此外，您还将找到专门从 NetSuite 提取这些数据的实用指南，确保您拥有进行准确流程分析和改进所需信息。

建议采集的属性
需要追踪的关键活动
NetSuite数据提取指南

不熟悉事件日志？了解如何创建流程挖掘事件日志.

下载模板

应付账款发票处理属性

这些是建议您在 event log 中纳入的 data 字段，以便全面分析应付账款发票处理流程。

5 必填 6 推荐 11 可选

	名称	描述
	Activity ActivityName	发票处理流程中发生的业务活动或事件的名称。
描述此 attribute 描述应付账款流程中的特定步骤或里程碑（如“供应商账单已创建”、“发票已批准”等）。分析这些 activities 的顺序和频率是 Process Mining 核心，可可视化流程流，识别变体、瓶颈或偏离之处。这些 activities 构成流程图中的节点。为何重要它定义了流程的各个步骤，便于流程图的可视化、过渡时间的计算以及瓶颈和返工循环的识别。获取方式源自NetSuite中的供应商账单和相关付款记录的系统日志、审计跟踪或状态变更。这通常需要转换逻辑。示例供应商账单已创建发票已审批执行付款已识别差异
	发票 Invoice	每张供应商发票的唯一标识符。
描述 “发票”作为主要的案例标识符，关联了从发票接收到最终付款的所有活动。此属性对于重构每张发票的端到端旅程至关重要。在分析中，它支持对单个发票流程进行筛选、聚合和详细检查，从而构成了变体分析和周期时间计算的核心基础。为何重要它是将所有相关 event 连接到单个流程实例的基本属性，从而能够对每张发票的生命周期进行端到端分析。获取方式这是 NetSuite 中 Vendor Bill 交易记录的主键，通常被称为 Transaction ID 或 Document Number。示例 INV-2023-001237894561VN54321A
	开始时间 EventTime	指示某项活动或事件开始的时间戳。
描述此 attribute 记录特定 activity 的精确日期和时间，提供每个 case 中 event 的时间顺序。此 timestamp 对所有基于时间的分析（如 cycle time 计算、流程持续时间及延迟识别）至关重要。它用于正确排序 event，并构成了绩效 KPI 的基础，例如“平均发票审批时间”和“Days Payable Outstanding”。为何重要它提供了 event 的时间顺序，这对于计算所有基于持续时间的指标、发现瓶颈以及了解流程绩效至关重要。获取方式与 NetSuite 交易记录和系统备注中的状态更改或创建/修改日期相关联的时间戳字段。示例 2023-10-26T10:00:00Z2023-11-15T14:35:10Z2024-01-05T09:12:05Z
	最后数据更新 LastDataUpdate	此事件数据上次从源系统刷新时的时间戳。
描述此 attribute 指示 event data 最近一次从 NetSuite 提取的时间。它反映了 Process Mining 工具中 data 的时效性。这对于理解分析的时效性很重要。用户可以查看 data 的最新程度，这对于跟踪近实时发票 status 的 operational dashboard 尤为重要。为何重要提供数据新鲜度透明度，使用户能够了解流程分析的最新程度以及何时预期进行下一次数据刷新。获取方式此时间戳由数据提取工具或数据管道在数据摄取时生成。示例 2024-03-10T02:00:00Z2024-03-11T02:00:00Z
	源系统 SourceSystem	数据提取来源系统。
描述此 attribute 标识流程 data 的来源。对于此 view，它将始终为 'NetSuite'。在具有多个 systems（例如，外部 OCR system 和 ERP）的环境中，此 field 对于 data lineage 和 troubleshooting 至关重要。它确认所有 event 都被正确地归因于记录的 source system。为何重要确保数据来源可追溯，这在多系统环境中至关重要，以便追溯数据源头进行验证和理解其背景。获取方式这是一个静态值（“NetSuite”），在数据提取和转换过程中填充。示例 NetSuite
	供应商名称 VendorName	提交此发票的供应商名称。
描述此 attribute 标识了与发票关联的供应商法定名称，是 transaction 的一项关键 master data。按供应商分析流程有助于识别特定供应商问题（如频繁不符、付款延迟或动态折扣机会），对“发票状态和账龄 Dashboard”至关重要，支持未结发票分类及 relationship management。为何重要允许按供应商进行绩效分析，有助于识别问题供应商、协商更优条款并有效管理合作关系。获取方式来自与供应商账单交易关联的供应商记录。该字段通常标记为‘供应商名称’或‘公司名称’。示例全球办公用品有限公司Tech Solutions LLCCreative Marketing Co.
	发票到期日 InvoiceDueDate	发票必须支付以避免罚款的截止日期。
描述此属性指明根据供应商的付款条件和发票日期确定的付款到期日。这是应付账款 (AP) 流程中的一个关键截止日期。此日期是“Payment Compliance Dashboard”和“Payment Term Adherence Rate” KPI 的基准。它用于确定付款是否按时、提前或延迟，这直接影响供应商关系，并可能产生滞纳金。为何重要作为衡量准时付款表现的主要基准，它对供应商关系和财务合规性至关重要。获取方式这是 Vendor Bill 交易记录上的一个标准“Due Date”字段。示例 2023-11-302023-12-152024-02-28
	发票金额 InvoiceAmount	发票的总金额。
描述此 attribute 表示供应商发票的总应付金额（不含扣除或折扣），是每个 case 的核心财务指标。Invoice amount 用于财务分析，例如按价值区间（高/低）分类发票，以判断流程路径差异。它也用于 dashboards，了解瓶颈或延迟的财务影响，并是 DPO 计算的基础。为何重要能够对流程低效进行财务影响分析，并允许按价值对发票进行细分，以优先处理高价值项目。获取方式供应商账单交易记录表头中的“金额”或“总计”字段。示例 1500.75250.0012500.50
	处理人用户 ProcessorUser	负责处理或录入发票的用户。
描述此 attribute 标识了负责对发票进行 data entry 或初步 processing 的应付账款团队成员。此 data 对于“AP 员工工作量分配 Dashboard”至关重要，有助于管理者分析工作量平衡、识别培训需求、衡量绩效，并可将错误追溯至 processor，调查根本原因。为何重要通过将活动归因于特定的应付账款（AP）人员，实现工作量分析、绩效监控以及错误根本原因分析。获取方式供应商账单早期活动对应的系统备注或审计追踪中的“创建人”或“修改人”字段。示例 j.doea.smithm.jones
	审批人 Approver	负责审批发票付款的用户。
描述此 attribute 标识了对发票进行最终审批的经理或预算负责人。一张发票在 lifecycle 中可能有多个 approver。它是“审批瓶颈分析 Dashboard”的关键维度，有助于通过分析审批时间，识别低效个人，重新分配发票以平衡 workload，并 streamline 整体审批流程。为何重要直接有助于识别审批瓶颈，并有助于分析审批链中相关管理者的工作量和绩效。获取方式此信息通常存储在与 Vendor Bill 交易相关的工作流历史记录或审批日志中。示例 s.chenp.williamsr.davis
	采购订单号 PurchaseOrderNumber	与发票关联的采购订单标识符（如适用）。
描述此 attribute 将供应商发票与预先批准的采购订单 (PO) 相关联。其存在与否是区分有无 PO 支撑发票的关键。此 field 对“采购订单/收货匹配效率 Dashboard”和“KPI”至关重要。根据PO支撑分析流程，有助于识别三方匹配效率提升和自动化机会。为何重要区分采购订单（PO）发票和非采购订单发票，这两种发票通常遵循不同的流程路径，并且具有不同的自动化潜力。这是分析匹配效率的关键。获取方式这通常位于 Vendor Bill 记录的明细项或表头中，将其关联到采购订单交易。示例 PO-004589PO-005123null
	付款条款 PaymentTerms	双方约定的发票付款条款（例如：Net 30，2% 10 Net 30）。
描述此 attribute 定义了供应商期望付款的条件，包括付款期限和任何潜在的提前付款折扣。付款条款用于计算“发票到期日”和任何“提前付款折扣日期”。它们对于“付款合规性 Dashboard”至关重要，并有助于分析获得提前付款折扣的机会，从而优化营运资金。为何重要它决定了付款截止日期和折扣机会，直接影响现金流管理以及获取节省的能力。获取方式供应商账单交易中的“付款条款”字段，通常继承自供应商主记录。示例账期30天账期60天2% 10, Net 30
	公司代码 CompanyCode	处理此发票的法人实体或子公司的标识符。
描述此属性指明组织内对发票负责的公司或子公司。这对于拥有多个法律实体的企业尤为重要。通过公司代码分析流程，可以比较业务不同部门的绩效。它能突出特定子公司的效率、合规性或工作量方面的差异，从而实现有针对性的改进措施。为何重要能够比较不同法律实体或子公司的流程绩效，促进有针对性的改进并确保企业治理。获取方式在 NetSuite 中，这对应于 OneWorld 账户交易记录上的“子公司”字段。示例 US01DE01UK01
	单据类型 DocumentType	正在处理的文档类型（例如，发票、贷项通知单）。
描述此 attribute 区分标准发票和其他相关文档，例如贷项通知单，这些文档可能遵循不同的 processing 规则或 workflow。按文档类型分析流程可确保您比较的是同类项目。例如，大额发票的审批流程可能比小额贷项通知单更为严格。这种细分提供了更准确的流程绩效视图。为何重要允许根据不同类型的财务文件对流程进行细分，这些文件可能具有不同的处理路径和关键绩效指标（KPI），从而实现更精确的分析。获取方式这可以从 NetSuite 中的 transaction type（例如“Vendor Bill”、“Vendor Credit”）中识别。示例标准发票贷项通知单借项通知单
	发票状态 InvoiceStatus	发票的当前处理状态。
描述此 attribute 指示供应商账单在 AP lifecycle 中的当前 state（如“未结”、“待审批”或“已全额支付”）。它是“发票状态和账龄 Dashboard”的关键 attribute，提供了当前 workload 和 liabilities 快照，支持聚焦未结或问题发票，并跟踪完成进度。为何重要提供发票在流程中的实时快照，这对于运营监控、工作量管理和财务预测至关重要。获取方式供应商账单交易记录中的“状态”字段。示例未结待审批已全额支付
	处理时间 ProcessingTime	积极处理某项活动所花费的时间。
描述此 attribute 衡量单个 activity 的从开始到结束的持续时间，代表 resource 积极参与 task 所花费的时间。与 cycle time 不同，processing time 有助于分析特定 task 所需实际工作量，例如衡量“尝试 PO 匹配”时间以评估效率并识别自动化机会。为何重要衡量某项activity的实际工作时长，有助于区分实际工作时间和闲置等待时间，以便更好地分析resource利用率和efficiency。获取方式通过计算活动的结束时间（EndTime）与开始时间（StartTime）之间的差值得出。要求每个活动都提供这两个时间戳。示例 PT5MPT1H30MPT8H
	币种 Currency	发票金额的币种代码（例如：USD、EUR）。
描述此属性指明发票的计价币种。它为“InvoiceAmount”提供了必要的背景信息。对于跨国组织来说，以单一、一致的币种分析数据至关重要。此字段支持正确的货币换算，并确保财务指标能够在不同区域或业务部门间进行同等比较。为何重要为所有金额提供必要的背景信息，确保准确的财务分析，尤其是在跨国运营中。获取方式供应商账单交易记录中的“币种”字段，通常与供应商主数据关联。示例 USDEURGBPCAD
	折扣日期 EarlyPaymentDiscountDate	有资格享受早期付款折扣的发票支付截止日期。
描述此属性指明根据“Payment Terms”（例如“2% 10, Net 30”中的“10”）有资格获得供应商折扣的最后付款日期。此日期是“Early Payment Discount Opportunities”dashboard 的主要驱动因素。通过将此日期与当前日期和付款日期进行比较，系统可以识别机会，衡量“Early Payment Discount Capture Rate” KPI，并帮助公司最大限度地节省成本。为何重要这是通过提前付款折扣实现成本节约最大化的关键日期；跟踪它有助于优化现金管理。获取方式这是 Vendor Bill 记录上的一个计算字段，源自发票日期和“Terms”字段。示例 2023-11-102024-01-20null
	支付日期 PaymentDate	发票支付的执行日期。
描述此 attribute 记录向供应商支付 cash disbursement 的 date，标志着发票的最终财务结算。此 date 用于确定许多 KPI 的实际流程结束时间（如“Days Payable Outstanding”和“Payment Term Adherence Rate”），是用于与“Invoice Due Date”和“Early Payment Discount Date”进行衡量比较的真实事件。为何重要它标志着流程的财务终结，也是计算支付合规性、DPO 和折扣获取 KPI 的基础。获取方式来自NetSuite中关联的账单支付交易记录的‘日期’字段。示例 2023-11-282023-12-142024-02-25
	是否已获取提前付款折扣 IsEarlyPaymentCaptured	一个指示是否成功获取了可用提前付款折扣的标志。
描述此计算型 boolean 属性用于检查具有可用折扣的发票是否在“Early Payment Discount Date”当天或之前完成支付。此属性对于衡量“Early Payment Discount Capture Rate” KPI 以及为“Early Payment Discount Opportunities”dashboard 提供支持至关重要。它为公司的折扣获取策略提供了明确的成功/失败指标，并能突显错失的节省机会。为何重要直接衡量财务或应付账款（AP）部门在实现成本节约方面的有效性，这是衡量财务绩效的关键指标。获取方式在数据转换过程中计算：对于有折扣的发票，满足PaymentDate <= EarlyPaymentDiscountDate。示例 true否null
	是否按时付款 IsOnTimePayment	一个指示发票是否在到期日或之前支付的标志。
描述此计算型 boolean 属性评估“Payment Date”是否小于或等于“Invoice Due Date”。它为每张发票的付款及时性提供了明确的二元结果。此属性直接支持“Payment Compliance Dashboard”，并用于计算“Payment Term Adherence Rate” KPI。它通过允许用户即时筛选所有逾期付款并调查其根本原因，从而简化了分析。为何重要简化了付款及时性分析，直接为遵守付款条款和供应商关系管理相关的关键绩效指标（KPI）提供支持。获取方式在数据转换过程中计算：满足PaymentDate <= InvoiceDueDate。示例 true否
	是否返工 IsRework	一个指示该活动是否属于返工循环的标志。
描述此计算型 boolean 属性用于识别代表重复工作的活动，例如第二次出现“Discrepancy Identified”event，或 invoice 被 rejected 后重新提交 approval。此属性对于“Rework and Error Analysis”dashboard 和“Invoice Rework Rate” KPI 至关重要。它使企业能够量化返工的频率和影响，帮助找出效率低下、错误和流程偏差的根源。为何重要通过识别和量化代表无效付出的活动，揭示流程低效环节，从而支持有针对性的改进措施，以提升质量和首次通过率。获取方式在数据转换过程中，通过分析给定案例的活动序列计算得出。例如，如果“发票已审批”之后是“发票已驳回”，然后再次“发票已审批”。示例 true否

必填推荐可选

应付账款发票处理活动

这些是您需要在 event log 中记录的关键流程步骤和里程碑，以便进行准确的流程发现和瓶颈识别。

6 推荐 8 可选

	活动	描述
	供应商账单已创建	标记供应商新发票在NetSuite中的录入。此信息来自供应商账单交易记录的创建日期，代表应付账款流程的正式开始。
为何重要确立所有发票处理周期时间计算的起点，这对于衡量整体流程效率和跟踪发票账龄至关重要。获取方式供应商账单交易记录中的“创建日期”字段。捕获 Vendor Bill 的交易创建事件。事件类型 explicit
	发票已审批	此事件表示供应商账单已获得指定审批人的支付授权。当账单的“审批状态”更新为“已批准”时，系统即会记录此事件。
为何重要这是一个关键里程碑，它结束了审批阶段，并允许发票过账并安排付款。它是衡量审批效率的关键数据点。获取方式 Vendor Bill 记录上“Approval Status”字段变为“Approved”的时间戳，记录在系统备注或工作流日志中。捕获工作流日志或系统备注时间戳，表示“审批状态”为“已批准”。事件类型 explicit
	发票已结案	标记供应商账单记录的最终结清，通常在账单已全额支付后。当供应商账单status变为“Paid in Full”时，即推断为已结清。
为何重要提供流程生命周期的明确结束event，确认该特定发票无需进一步操作。获取方式从供应商账单记录上“状态”字段更改为“已全额支付”的 timestamp 中推断，如系统备注中所追踪。捕获 “Status”字段变为“Paid in Full”的时间戳。事件类型 inferred
	发票已过账至总账	标记供应商账单的财务影响正式记录到总账的时刻。此信息由账单获批且“Posting”flag被设定时的transaction date捕获。
为何重要这是一个关键财务控制点，确认公司已正式认可负债。过账延迟可能影响财务报告的准确性。获取方式与从供应商账单创建的总账（GL）交易关联的过账日期。账单上的“过账”字段将被核查。捕获与 Vendor Bill 相关联的 GL 总账过账的交易日期。事件类型 explicit
	审批提交	此事件标志着 Vendor Bill 正式进入审批工作流。它在 bill 的“Approval Status”从草稿状态变为“Pending Approval”时被记录。
为何重要此 activity 是衡量审批周期时间的起点，这对于识别特定审批人或部门的瓶颈至关重要。获取方式从供应商账单记录上“审批状态”更改为“待审批”的 timestamp 中推断，如系统备注中所追踪。捕获 “Approval Status”字段变为“Pending Approval”的时间戳。事件类型 inferred
	执行付款	该事件表示对发票的最终支付。其发生日期将从应用于供应商账单的供应商付款记录的交易日期中获取。
为何重要这是 AP 流程的主要终点，对于计算端到端周期时间、付款条款合规性，以及 Days Payable Outstanding (DPO) 至关重要。获取方式与供应商账单关联的供应商付款交易记录中的“日期”字段。捕获应用于 bill 的 Vendor Payment 记录的交易日期。事件类型 explicit
	发票已重新路由进行审批	当发票因更改或拒绝而被退回至早期stage或不同的approver时发生。当“Approval Status”从“Pending Approval”变回另一个state，然后再次变为“Pending Approval”时，即推断为发生此情况。
为何重要识别重新路由 event 是理解审批流程中返工循环的关键，这些循环会显著延长处理周期。获取方式从系统备注中推断，通过检测同一账单的“审批状态”多次更改为“待审批”的序列。捕获分析系统日志中“审批状态”变化的序列。事件类型 inferred
	发票已驳回	此事件表示供应商账单在审批流程中被正式拒绝，需要修改并重新提交。当账单的“审批状态”更新为“已拒绝”时，系统即会记录此事件。
为何重要跟踪驳回对于返工分析至关重要，有助于找出常见失败原因（例如编码错误、政策违规），并提高首次通过审批率。获取方式 Vendor Bill 记录上“Approval Status”字段变为“Rejected”的时间戳，记录在系统备注中。捕获工作流日志或系统备注时间戳，表示“审批状态”为“已拒绝”。事件类型 explicit
	安排付款	此 activity 表示供应商账单已被选定进行付款并已纳入付款批次。当创建具有未来付款日期的供应商 Payment transaction 时，此 activity 就会被捕获。
为何重要此事件提供了支付流程的可见性，有助于现金流预测并管理付款时间，从而抓住提前付款折扣机会。获取方式应用于供应商账单的供应商付款交易记录的创建日期。捕获相关联的供应商付款交易记录的创建时间戳。事件类型 explicit
	尝试采购订单匹配	该操作指将供应商账单与相应采购订单关联，以进行验证。当采购订单（PO）首次在供应商账单记录的“物料”或“费用”子列表中被关联，且发生在审批之前时，即可推断出此操作。
为何重要跟踪此步骤有助于分析匹配流程的效率，并识别甚至在发票提交审批之前的延迟。获取方式从系统备注日志中推断，该日志显示“创建自”字段的初始填充或供应商账单上的行项目级别采购订单引用。捕获检测系统备注中采购订单（PO）参考字段的填充情况。事件类型 inferred
	已获得提前付款折扣	当发票付款在提前付款折扣截止日期前完成时触发的计算事件。该事件通过比较付款日期与供应商账单上的折扣条款计算得出。
为何重要直接衡量应付账款（AP）团队在获取折扣方面的成功程度，这直接影响公司的盈利能力和现金管理策略。获取方式这是一个计算事件。它需要比较 Vendor Payment 交易中的“Date”与从 Vendor Bill 的“Terms”字段中派生出的折扣日期。捕获比较供应商付款的“日期”与从供应商账单“条款”中得出的折扣日期。事件类型 calculated
	已识别差异	当发票、采购订单或收货单之间发现不匹配，从而阻止进一步 processing 时，此 activity 就会发生。这通常根据用户设置的特定“审批状态”来推断，例如“暂停”或“待澄清”。
为何重要突出此活动有助于查明验证流程中产生阻碍和返工的根源，而这些正是造成付款延迟的主要原因。获取方式从供应商账单“审批状态”字段变为非标准待处理状态（例如“已暂停”）的更改中推断而来。可能需要自定义状态配置。捕获跟踪“Approval Status”字段的更改，以表明暂停或待查。事件类型 inferred
	已识别逾期付款	当发票付款晚于到期日时触发的计算事件。该事件通过比较付款执行日期与供应商账单上注明的到期日来确定。
为何重要此 activity 对于监控付款合规性以及管理供应商关系至关重要。频繁的逾期付款会损害供应商信任。获取方式通过比较供应商付款交易的“日期”与供应商账单记录中的“到期日”字段计算得出。若付款日期晚于到期日，此事件即发生。捕获比较供应商付款的“日期”与供应商账单的“到期日”。事件类型 calculated
	贷项通知单已应用	当供应商贷项通知单应用于供应商账单时发生，以减少所欠金额。此信息由关联这两个交易的应用event捕获。
为何重要应用贷项通知单是结清发票的一种重要方式。跟踪此操作有助于了解核销和退货如何影响整个应付账款流程。获取方式供应商贷记交易应用于供应商账单时所记录的应用日期。此信息可在账单的相关记录中查看。捕获将 Vendor Credit 应用于 Vendor Bill 的时间戳。事件类型 explicit

推荐可选

提取指南

如何从 NetSuite 获取您的数据

步骤

导航至创建已保存的搜索: 使用具有创建/编辑已保存的搜索权限的角色登录 NetSuite。导航到报告 > 已保存的搜索 > 所有已保存的搜索 > 新建。从搜索类型列表中选择事务。
定义搜索条件: 在条件选项卡中，定义主要筛选条件以选择相关的发票（供应商账单）。
- 将类型设为供应商账单。
- 将主行设为 True。这将把搜索重点放在标题层级信息上。
- 添加创建日期筛选器，将数据提取限制在特定时间段内（例如，在过去6个月内）。
定义常见属性的结果列: 进入结果选项卡。添加以下字段，它们将作为发票中所有事件的通用属性。
- 文档编号 (自定义标签: Invoice)
- 实体 (自定义标签: VendorName)
- 金额 (自定义标签: InvoiceAmount)
- 到期日期 (自定义标签: InvoiceDueDate)
- 创建人 (自定义标签: ProcessorUser)
- 公式（文本）: 将公式设置为 '{source}' (自定义标签: SourceSystem)。这会将该列填充为“NetSuite”。
- 公式（日期/时间）: 将公式设置为 {today} (自定义标签: LastDataUpdate)。
定义活动的结果列: 这是最关键的步骤。对于这14个活动中的每一个，您将添加两个公式列：一个用于活动名称 (ActivityName)，另一个用于事件时间 (EventTime)。这将创建一个宽格式数据集，需要稍后进行转换。
- 发票已批准示例:
  - 添加公式（文本），其值为 CASE WHEN {approvalstatus} = 'Approved' THEN 'Invoice Approved' ELSE NULL END。设置一个自定义标签，例如 ActivityName_Approved。
  - 添加公式（日期/时间），其值为 CASE WHEN {approvalstatus} = 'Approved' THEN {systemnotes.date} WHERE systemnotes.field = 'Approval Status' and systemnotes.newvalue = 'Approved' ELSE NULL END。设置一个自定义标签，例如 EventTime_Approved。注意：获取状态更改的精确时间戳通常需要深入系统日志，这可能很复杂。一个更简单但不太精确的替代方案是使用专用的 {approveddate} 字段（如果可用）。
- 使用下方 query 部分提供的逻辑，对所有14个所需活动重复此过程。
配置搜索设置: 在受众子选项卡下，确保此搜索可供拥有相应角色或需要运行导出操作的用户访问。为该搜索指定一个描述性名称，例如 ProcessMind 应付账款提取。
保存并运行搜索: 点击保存并运行以执行搜索。在 NetSuite 用户界面中检查结果，确保数据以宽格式按预期显示。
将数据导出为 CSV: 在搜索结果页面上，点击导出图标（CSV、Excel 或 PDF），然后选择 CSV。
转换数据（逆透视）: 导出的 CSV 文件将每张发票包含一行，并有许多用于活动和时间戳的列（例如 ActivityName_Created、EventTime_Created、ActivityName_Approved、EventTime_Approved）。这种“宽”格式必须转换为“长”格式的事件日志。
- 使用 Microsoft Excel（通过 Power Query）、Python（通过 Pandas）或其他数据处理工具打开 CSV 文件。
- 使用逆透视功能。选择所有常见属性列（Invoice、VendorName 等），然后逆透视所有 ActivityName_... 和 EventTime_... 列。
- 这种转换将创建所需的事件日志结构，即每项活动对应一行。
清理并格式化最终文件: 逆透视后，您将得到表示属性和值的列。将这些列重命名为 ActivityName 和 EventTime。筛选掉 ActivityName 或 EventTime 值为 NULL 的行。确保最终的列标题与 ProcessMind 架构（Invoice、ActivityName、EventTime` 等）匹配。
保存最终事件日志: 将转换后的数据保存为新的 CSV 文件，即可上传至 ProcessMind。

配置

前提条件 (Prerequisites)：拥有 Saved Searches 创建或完整权限级别的用户角色。该角色还必须对 Transaction 记录（特别是供应商账单、供应商付款、供应商贷项）以及相关实体记录（供应商、员工）具有查看权限。
搜索类型 (Search Type)：此流程始终应以 Transaction 搜索类型开始。
日期范围筛选 (Date Range Filtering)：应用日期范围过滤器（例如 Date Created）对于限制数据集大小至关重要。建议从较小的范围（例如 3-6 个月）开始，以测试搜索性能并验证结果，然后再处理更长历史周期的数据。
主行筛选 (Main Line Filter)：通常建议使用 Criteria > Main Line > is True 以确保每笔交易只获得一条结果。然而，对于某些发生在行级别的活动，例如“尝试采购订单匹配”，您可能需要单独的搜索或更复杂的公式，而不是使用此过滤器。
自定义字段 (Custom Fields)：您的 NetSuite 实例可能使用自定义字段来管理应付账款 (AP) 流程（例如，使用自定义的 AP Process Status 字段而不是标准的 Approval Status 字段）。您必须识别这些字段，并在搜索条件和结果公式中替换它们。
性能考量 (Performance Considerations)：如果一个 Saved Search 包含了所有 14 项活动的公式，它在 NetSuite 中运行可能会很慢或超时。建议将逻辑拆分为多个 Saved Search（例如，一个用于账单创建/批准，一个用于付款），并在进行数据透视前合并导出的文件。

a 查询示例 config

`config
# NetSuite Saved Search Configuration for Accounts Payable Event Log Extraction
# This configuration describes the settings for a single, comprehensive Saved Search.
# The output is a 'wide' file that must be unpivoted into an event log.

SearchType: "Transaction"

# ====================================================================
# CRITERIA
# ====================================================================
# Define the filters to select the base records
# --------------------------------------------------------------------

Filters: [
  {
    "field": "Type",
    "operator": "is",
    "value": "Vendor Bill"
  },
  {
    "field": "Main Line",
    "operator": "is",
    "value": "True"
  },
  {
    "field": "Date Created",
    "operator": "within",
    "value": "[Specify Date Range, e.g., thisfiscalquarter]"
  }
]

# ====================================================================
# RESULTS
# ====================================================================
# Define the columns for the output. The final CSV will have these columns.
# Common attributes are listed first, followed by pairs of columns for each activity.
# --------------------------------------------------------------------

Columns: [
  // --- Common Attributes ---
  { "field": "Document Number", "label": "Invoice" },
  { "field": "Entity", "label": "VendorName" },
  { "field": "Amount", "label": "InvoiceAmount" },
  { "field": "Applied To Transaction", "label": "PurchaseOrderNumber" },
  { "field": "Created By", "label": "ProcessorUser" },
  { "field": "Next Approver", "label": "Approver" },
  { "field": "Due Date", "label": "InvoiceDueDate" },
  { "formula": "'NetSuite'", "type": "Text", "label": "SourceSystem" },
  { "formula": "{today}", "type": "Date/Time", "label": "LastDataUpdate" },

  // --- Activity 1: Vendor Bill Created ---
  { "formula": "'Vendor Bill Created'", "type": "Text", "label": "ActivityName_Created" },
  { "field": "Date Created", "label": "EventTime_Created" },

  // --- Activity 2: PO Matching Attempted ---
  { "formula": "CASE WHEN {appliedtotransaction} IS NOT NULL THEN 'PO Matching Attempted' ELSE NULL END", "type": "Text", "label": "ActivityName_POMatched" },
  { "formula": "CASE WHEN {appliedtotransaction} IS NOT NULL THEN {datecreated} ELSE NULL END", "type": "Date/Time", "label": "EventTime_POMatched" },

  // --- Activity 3: Discrepancy Identified ---
  { "formula": "CASE WHEN {approvalstatus} = 'Rejected' THEN 'Discrepancy Identified' ELSE NULL END", "type": "Text", "label": "ActivityName_Discrepancy" },
  { "formula": "(SELECT MIN(systemnotes.date) FROM systemnote WHERE systemnote.recordid = {internalid} AND systemnote.field = 'TRANSACTION.APPROVALSTATUS' AND systemnote.newvalue = 'Rejected')", "type": "Date/Time", "label": "EventTime_Discrepancy" },

  // --- Activity 4: Approval Submitted ---
  { "formula": "CASE WHEN {approvalstatus} != 'Pending Approval' AND {approvalstatus} != 'Approved' THEN NULL ELSE 'Approval Submitted' END", "type": "Text", "label": "ActivityName_Submitted" },
  { "formula": "(SELECT MIN(systemnotes.date) FROM systemnote WHERE systemnote.recordid = {internalid} AND systemnote.field = 'TRANSACTION.APPROVALSTATUS' AND systemnote.newvalue = 'Pending Approval')", "type": "Date/Time", "label": "EventTime_Submitted" },

  // --- Activity 5: Invoice Re-Routed For Approval ---
  { "formula": "CASE WHEN (SELECT COUNT(systemnotes.date) FROM systemnote WHERE systemnote.recordid = {internalid} AND systemnote.field = 'TRANSACTION.APPROVALSTATUS' AND systemnote.newvalue = 'Pending Approval') > 1 THEN 'Invoice Re-Routed For Approval' ELSE NULL END", "type": "Text", "label": "ActivityName_ReRouted" },
  { "formula": "(SELECT MAX(systemnotes.date) FROM systemnote WHERE systemnote.recordid = {internalid} AND systemnote.field = 'TRANSACTION.APPROVALSTATUS' AND systemnote.newvalue = 'Pending Approval' AND systemnotes.date < (SELECT MAX(sub_notes.date) FROM systemnote sub_notes WHERE sub_notes.recordid = {internalid} AND sub_notes.field = 'TRANSACTION.APPROVALSTATUS' AND sub_notes.newvalue = 'Pending Approval'))", "type": "Date/Time", "label": "EventTime_ReRouted" },

  // --- Activity 6: Invoice Approved ---
  { "formula": "CASE WHEN {approvalstatus} = 'Approved' THEN 'Invoice Approved' ELSE NULL END", "type": "Text", "label": "ActivityName_Approved" },
  { "formula": "(SELECT MIN(systemnotes.date) FROM systemnote WHERE systemnote.recordid = {internalid} AND systemnote.field = 'TRANSACTION.APPROVALSTATUS' AND systemnote.newvalue = 'Approved')", "type": "Date/Time", "label": "EventTime_Approved" },

  // --- Activity 7: Invoice Rejected ---
  { "formula": "CASE WHEN {approvalstatus} = 'Rejected' THEN 'Invoice Rejected' ELSE NULL END", "type": "Text", "label": "ActivityName_Rejected" },
  { "formula": "(SELECT MAX(systemnotes.date) FROM systemnote WHERE systemnote.recordid = {internalid} AND systemnote.field = 'TRANSACTION.APPROVALSTATUS' AND systemnote.newvalue = 'Rejected')", "type": "Date/Time", "label": "EventTime_Rejected" },

  // --- Activity 8: Invoice Posted To GL ---
  { "formula": "CASE WHEN {posting} = 'Yes' THEN 'Invoice Posted To GL' ELSE NULL END", "type": "Text", "label": "ActivityName_Posted" },
  { "field": "Date", "label": "EventTime_Posted" },

  // --- Activity 9: Payment Scheduled ---
  { "formula": "CASE WHEN {payingtransaction.type} = 'Vendor Payment' AND {payingtransaction.trandate} > {today} THEN 'Payment Scheduled' ELSE NULL END", "type": "Text", "label": "ActivityName_Scheduled" },
  { "formula": "CASE WHEN {payingtransaction.type} = 'Vendor Payment' AND {payingtransaction.trandate} > {today} THEN {payingtransaction.datecreated} ELSE NULL END", "type": "Date/Time", "label": "EventTime_Scheduled" },

  // --- Activity 10: Payment Executed ---
  { "formula": "CASE WHEN {status} = 'Paid in Full' OR {status} = 'Pending Approval' THEN 'Payment Executed' ELSE NULL END", "type": "Text", "label": "ActivityName_Executed" },
  { "field": "Paying Transaction Date", "label": "EventTime_Executed" },

  // --- Activity 11: Invoice Closed ---
  { "formula": "CASE WHEN {status} = 'Paid in Full' THEN 'Invoice Closed' ELSE NULL END", "type": "Text", "label": "ActivityName_Closed" },
  { "field": "Paying Transaction Date", "label": "EventTime_Closed" },

  // --- Activity 12: Early Payment Captured ---
  { "formula": "CASE WHEN {payingtransaction.trandate} < {discountdate} AND {discountamount} IS NOT NULL THEN 'Early Payment Captured' ELSE NULL END", "type": "Text", "label": "ActivityName_EarlyPay" },
  { "formula": "CASE WHEN {payingtransaction.trandate} < {discountdate} AND {discountamount} IS NOT NULL THEN {payingtransaction.trandate} ELSE NULL END", "type": "Date/Time", "label": "EventTime_EarlyPay" },

  // --- Activity 13: Late Payment Identified ---
  { "formula": "CASE WHEN {daysoverdue} > 0 AND {status} = 'Paid in Full' THEN 'Late Payment Identified' ELSE NULL END", "type": "Text", "label": "ActivityName_LatePay" },
  { "formula": "CASE WHEN {daysoverdue} > 0 AND {status} = 'Paid in Full' THEN {payingtransaction.trandate} ELSE NULL END", "type": "Date/Time", "label": "EventTime_LatePay" },

  // --- Activity 14: Credit Memo Applied ---
  { "formula": "CASE WHEN {payingtransaction.type} = 'Vendor Credit' THEN 'Credit Memo Applied' ELSE NULL END", "type": "Text", "label": "ActivityName_CreditMemo" },
  { "formula": "CASE WHEN {payingtransaction.type} = 'Vendor Credit' THEN {payingtransaction.trandate} ELSE NULL END", "type": "Date/Time", "label": "EventTime_CreditMemo" }
]
`

步骤

前提条件: 请确保您的 NetSuite 账户已启用 SuiteAnalytics Connect 模块。确认您的用户角色具备“SuiteAnalytics Connect”权限，并有权访问所需的记录（供应商账单、供应商付款、采购订单、系统日志）。
安装和配置驱动程序: 从 NetSuite 用户界面中主页 > 设置偏好 > 分析驱动程序下载适用于您操作系统的 NetSuite ODBC（或 JDBC）驱动程序。按照安装说明进行操作，并配置一个新的数据源名称 (DSN)，指向 NetSuite 服务。
建立连接: 打开您首选的 SQL 客户端（例如 DBeaver、Power BI、Tableau）。使用已配置的驱动程序/DSN 创建新连接。您将需要您的 NetSuite 账户 ID、角色 ID 和用于身份验证的用户凭据。
准备查询: 将下方 query 部分中提供的完整 SuiteQL 查询复制到您的 SQL 客户端的查询编辑器中。
自定义占位符: 修改查询的 WHERE 子句中的占位符值。至少，您必须设置 [START_DATE] 和 [END_DATE] 来定义您的分析期。此外，如果您使用的是 NetSuite OneWorld 账户，请调整 [SUBSIDIARY_ID]。
调整自定义逻辑: 查阅标有 -- CUSTOMIZABLE 等注释的部分。查询的这些部分根据特定的状态值推断出“已识别差异”等活动。您必须更新这些值，以匹配您组织的特定 NetSuite 配置和业务流程。
执行查询: 对 NetSuite 数据库运行自定义查询。根据日期范围和数据量，这可能需要几分钟才能完成。
导出结果: 查询完成后，将结果集从您的 SQL 客户端导出为 CSV 文件。
准备上传: 确保导出的 CSV 文件是 UTF-8 编码。验证列标题是否与 ProcessMind 所需和推荐的属性（例如 Invoice、ActivityName、EventTime）匹配。文件现在已准备好上传。

配置

SuiteAnalytics Connect：此 NetSuite 附加模块是使用此抽取方法所必需的。它提供对您的 NetSuite 数据副本的只读访问。
用户角色权限 (User Role Permissions)：用于连接的 NetSuite 角色必须启用 'SuiteAnalytics Connect' 权限。它还要求对以下记录具有查看级别访问权限：Transactions（供应商账单、供应商付款、供应商贷项）、Entities（供应商、员工）和 System Notes。
日期范围筛选 (Date Range Filtering)：对查询进行特定日期范围的过滤（例如 trandate BETWEEN 'YYYY-MM-DD' AND 'YYYY-MM-DD'）至关重要，以确保执行时间可控。建议从较小的范围（例如 3-6 个月）开始，然后再进行完整抽取。
子公司筛选 (Subsidiary Filtering)：对于 NetSuite OneWorld 账户，应始终包含 WHERE 子句并按 subsidiary ID 进行筛选，以隔离特定法律实体的数据并提高查询性能。
自定义审批工作流 (Custom Approval Workflows)：提供的查询假定使用供应商账单上的标准“审批状态”字段。如果您的组织使用自定义 SuiteFlow 或脚本，并通过自定义字段/记录进行审批，则查询中涉及 SystemNote 表中 approvalstatus 字段的部分将需要大量修改。

a 查询示例 sql

`sql
-- This query extracts an event log for the Accounts Payable Invoice Processing from NetSuite.
-- It uses a UNION ALL approach to gather 14 distinct activities into a single file.

WITH VendorBillsInScope AS (
    -- CTE to select the primary Vendor Bills to analyze.
    -- Filtering here is critical for performance.
    SELECT
        Transaction.ID AS BillID,
        Transaction.tranid AS Invoice,
        Transaction.trandate AS BillDate,
        Transaction.duedate AS InvoiceDueDate,
        Transaction.foreignTotal AS InvoiceAmount,
        Transaction.entity AS VendorID,
        Transaction.createdBy AS ProcessorUserID,
        Transaction.status AS BillStatus,
        Transaction.approvalStatus AS ApprovalStatus,
        Transaction.discountDate AS DiscountDate
    FROM
        Transaction
    WHERE
        Transaction.type = 'VendBill'
        -- CRITICAL: Define the date range for the extraction
        AND Transaction.trandate BETWEEN TO_DATE('[START_DATE]', 'YYYY-MM-DD') AND TO_DATE('[END_DATE]', 'YYYY-MM-DD')
        -- OPTIONAL: Filter by a specific subsidiary for NetSuite OneWorld accounts
        -- AND Transaction.subsidiary = [SUBSIDIARY_ID]
),

-- Base information for joins, including vendor, processor, and PO data.
BaseInfo AS (
    SELECT
        vb.BillID,
        vb.Invoice,
        vb.InvoiceAmount,
        vb.InvoiceDueDate,
        vb.DiscountDate,
        vendor.companyName AS VendorName,
        processor.entityId AS ProcessorUser,
        LISTAGG(DISTINCT po.tranid, ', ') WITHIN GROUP (ORDER BY po.tranid) AS PurchaseOrderNumber
    FROM
        VendorBillsInScope vb
    LEFT JOIN
        Entity vendor ON vb.VendorID = vendor.ID
    LEFT JOIN
        Employee processor ON vb.ProcessorUserID = processor.ID
    LEFT JOIN
        TransactionLine tl ON vb.BillID = tl.Transaction
    LEFT JOIN
        Transaction po ON tl.purchaseOrder = po.ID AND po.type = 'PurchOrd'
    GROUP BY
        vb.BillID, vb.Invoice, vb.InvoiceAmount, vb.InvoiceDueDate, vb.DiscountDate, vendor.companyName, processor.entityId
),

-- System Notes are used to track status changes for approvals, rejections, etc.
Notes AS (
    SELECT
        sn.transactionId AS BillID,
        sn.date AS NoteDate,
        sn.field AS NoteField,
        sn.newValue AS NoteNewValue,
        sn.oldValue AS NoteOldValue,
        approver.entityId AS Approver
    FROM
        SystemNote sn
    JOIN
        VendorBillsInScope vb ON sn.transactionId = vb.BillID
    LEFT JOIN
        Employee approver ON sn.author = approver.ID
    WHERE
        -- Filtering to relevant fields improves performance
        sn.field IN ('approvalstatus', 'status')
)

-- 1. Vendor Bill Created
SELECT
    bi.Invoice AS "Invoice",
    'Vendor Bill Created' AS "ActivityName",
    vb.BillDate AS "EventTime",
    'NetSuite' AS "SourceSystem",
    BUILTIN.CURRRENT_TIMESTAMP() AS "LastDataUpdate",
    bi.VendorName AS "VendorName",
    bi.InvoiceAmount AS "InvoiceAmount",
    bi.PurchaseOrderNumber AS "PurchaseOrderNumber",
    bi.ProcessorUser AS "ProcessorUser",
    NULL AS "Approver",
    bi.InvoiceDueDate AS "InvoiceDueDate"
FROM
    VendorBillsInScope vb
JOIN
    BaseInfo bi ON vb.BillID = bi.BillID

UNION ALL

-- 2. PO Matching Attempted (Inferred from PO link on creation date)
SELECT
    bi.Invoice,
    'PO Matching Attempted',
    vb.BillDate, -- Occurs at the same time as creation
    'NetSuite',
    BUILTIN.CURRRENT_TIMESTAMP(),
    bi.VendorName,
    bi.InvoiceAmount,
    bi.PurchaseOrderNumber,
    bi.ProcessorUser,
    NULL,
    bi.InvoiceDueDate
FROM
    VendorBillsInScope vb
JOIN
    BaseInfo bi ON vb.BillID = bi.BillID
WHERE
    bi.PurchaseOrderNumber IS NOT NULL

UNION ALL

-- 3. Discrepancy Identified (CUSTOMIZABLE: Inferred from status change to 'On Hold')
SELECT
    bi.Invoice,
    'Discrepancy Identified',
    n.NoteDate,
    'NetSuite',
    BUILTIN.CURRRENT_TIMESTAMP(),
    bi.VendorName,
    bi.InvoiceAmount,
    bi.PurchaseOrderNumber,
    bi.ProcessorUser,
    n.Approver, -- User who placed it on hold
    bi.InvoiceDueDate
FROM
    Notes n
JOIN
    BaseInfo bi ON n.BillID = bi.BillID
WHERE
    n.NoteField = 'approvalstatus' 
    -- CUSTOMIZABLE: Update 'On Hold' to match the status your company uses for discrepancies.
    AND n.NoteNewValue = 'On Hold'

UNION ALL

-- 4. Approval Submitted
SELECT
    bi.Invoice,
    'Approval Submitted',
    n.NoteDate,
    'NetSuite',
    BUILTIN.CURRRENT_TIMESTAMP(),
    bi.VendorName,
    bi.InvoiceAmount,
    bi.PurchaseOrderNumber,
    bi.ProcessorUser,
    n.Approver, -- User who submitted for approval
    bi.InvoiceDueDate
FROM
    Notes n
JOIN
    BaseInfo bi ON n.BillID = bi.BillID
WHERE
    n.NoteField = 'approvalstatus' AND n.NoteNewValue = 'Pending Approval'

UNION ALL

-- 5. Invoice Re-Routed For Approval (Inferred by status returning to Pending Approval)
SELECT
    bi.Invoice,
    'Invoice Re-Routed For Approval',
    n.NoteDate,
    'NetSuite',
    BUILTIN.CURRRENT_TIMESTAMP(),
    bi.VendorName,
    bi.InvoiceAmount,
    bi.PurchaseOrderNumber,
    bi.ProcessorUser,
    n.Approver,
    bi.InvoiceDueDate
FROM
    Notes n
JOIN
    BaseInfo bi ON n.BillID = bi.BillID
WHERE
    n.NoteField = 'approvalstatus' 
    AND n.NoteNewValue = 'Pending Approval'
    AND n.NoteOldValue IN ('Rejected', 'On Hold') -- Capture re-submission after rejection/hold

UNION ALL

-- 6. Invoice Approved
SELECT
    bi.Invoice,
    'Invoice Approved',
    n.NoteDate,
    'NetSuite',
    BUILTIN.CURRRENT_TIMESTAMP(),
    bi.VendorName,
    bi.InvoiceAmount,
    bi.PurchaseOrderNumber,
    bi.ProcessorUser,
    n.Approver,
    bi.InvoiceDueDate
FROM
    Notes n
JOIN
    BaseInfo bi ON n.BillID = bi.BillID
WHERE
    n.NoteField = 'approvalstatus' AND n.NoteNewValue = 'Approved'

UNION ALL

-- 7. Invoice Rejected
SELECT
    bi.Invoice,
    'Invoice Rejected',
    n.NoteDate,
    'NetSuite',
    BUILTIN.CURRRENT_TIMESTAMP(),
    bi.VendorName,
    bi.InvoiceAmount,
    bi.PurchaseOrderNumber,
    bi.ProcessorUser,
    n.Approver,
    bi.InvoiceDueDate
FROM
    Notes n
JOIN
    BaseInfo bi ON n.BillID = bi.BillID
WHERE
    n.NoteField = 'approvalstatus' AND n.NoteNewValue = 'Rejected'

UNION ALL

-- 8. Invoice Posted To GL (Happens upon approval)
SELECT
    bi.Invoice,
    'Invoice Posted To GL',
    n.NoteDate,
    'NetSuite',
    BUILTIN.CURRRENT_TIMESTAMP(),
    bi.VendorName,
    bi.InvoiceAmount,
    bi.PurchaseOrderNumber,
    bi.ProcessorUser,
    n.Approver,
    bi.InvoiceDueDate
FROM
    Notes n
JOIN
    BaseInfo bi ON n.BillID = bi.BillID
WHERE
    n.NoteField = 'approvalstatus' AND n.NoteNewValue = 'Approved'

UNION ALL

-- 9. Payment Scheduled & 10. Payment Executed & 12. Early & 13. Late Payments
WITH Payments AS (
    SELECT
        tp.previousDoc AS BillID,
        vp.trandate AS PaymentExecutionDate,
        vp.createdDate AS PaymentScheduledDate
    FROM
        TransactionPayment tp
    JOIN
        Transaction vp ON tp.nextDoc = vp.ID AND vp.type = 'VendPymt'
    WHERE
        tp.previousDoc IN (SELECT BillID FROM VendorBillsInScope)
)
SELECT p.Invoice, p.ActivityName, p.EventTime, p.SourceSystem, p.LastDataUpdate, p.VendorName, p.InvoiceAmount, p.PurchaseOrderNumber, p.ProcessorUser, p.Approver, p.InvoiceDueDate FROM (
    SELECT bi.Invoice, 'Payment Scheduled' AS ActivityName, p.PaymentScheduledDate AS EventTime, 'NetSuite' AS SourceSystem, BUILTIN.CURRRENT_TIMESTAMP() AS LastDataUpdate, bi.VendorName, bi.InvoiceAmount, bi.PurchaseOrderNumber, bi.ProcessorUser, NULL AS Approver, bi.InvoiceDueDate FROM Payments p JOIN BaseInfo bi ON p.BillID = bi.BillID
    UNION ALL
    SELECT bi.Invoice, 'Payment Executed', p.PaymentExecutionDate, 'NetSuite', BUILTIN.CURRRENT_TIMESTAMP(), bi.VendorName, bi.InvoiceAmount, bi.PurchaseOrderNumber, bi.ProcessorUser, NULL, bi.InvoiceDueDate FROM Payments p JOIN BaseInfo bi ON p.BillID = bi.BillID
    UNION ALL
    SELECT bi.Invoice, 'Early Payment Captured', p.PaymentExecutionDate, 'NetSuite', BUILTIN.CURRRENT_TIMESTAMP(), bi.VendorName, bi.InvoiceAmount, bi.PurchaseOrderNumber, bi.ProcessorUser, NULL, bi.InvoiceDueDate FROM Payments p JOIN BaseInfo bi ON p.BillID = bi.BillID WHERE p.PaymentExecutionDate <= bi.DiscountDate
    UNION ALL
    SELECT bi.Invoice, 'Late Payment Identified', p.PaymentExecutionDate, 'NetSuite', BUILTIN.CURRRENT_TIMESTAMP(), bi.VendorName, bi.InvoiceAmount, bi.PurchaseOrderNumber, bi.ProcessorUser, NULL, bi.InvoiceDueDate FROM Payments p JOIN BaseInfo bi ON p.BillID = bi.BillID WHERE p.PaymentExecutionDate > bi.InvoiceDueDate
) p

UNION ALL

-- 11. Invoice Closed (Paid in Full)
SELECT
    bi.Invoice,
    'Invoice Closed',
    n.NoteDate,
    'NetSuite',
    BUILTIN.CURRRENT_TIMESTAMP(),
    bi.VendorName,
    bi.InvoiceAmount,
    bi.PurchaseOrderNumber,
    bi.ProcessorUser,
    NULL,
    bi.InvoiceDueDate
FROM
    Notes n
JOIN
    BaseInfo bi ON n.BillID = bi.BillID
WHERE
    n.NoteField = 'status' AND n.NoteNewValue = 'Paid In Full'

UNION ALL

-- 14. Credit Memo Applied
SELECT 
    bi.Invoice,
    'Credit Memo Applied',
    vc.trandate AS EventTime,
    'NetSuite' AS SourceSystem,
    BUILTIN.CURRRENT_TIMESTAMP() AS LastDataUpdate,
    bi.VendorName,
    bi.InvoiceAmount,
    bi.PurchaseOrderNumber,
    bi.ProcessorUser,
    NULL AS Approver,
    bi.InvoiceDueDate
FROM 
    TransactionLink tl
JOIN 
    Transaction vc ON tl.previousDoc = vc.ID AND vc.type = 'VendCred'
JOIN 
    BaseInfo bi ON tl.nextDoc = bi.BillID;
`

步骤

前提条件: 请确保您已安装 Python 3.6+，并安装了 requests、requests-oauthlib 和 pandas 库。您可以使用 pip 命令安装它们：pip install requests requests-oauthlib pandas。
启用 NetSuite 功能: 在 NetSuite 中，管理员必须启用 SuiteTalk Web 服务。导航到设置 > 公司 > 启用功能 > SuiteCloud。勾选 SUITEANALYTICS WORKBOOK 和 SUITETALK (WEB SERVICES) 的复选框。
创建集成记录和访问令牌: 导航到设置 > 集成 > 管理集成 > 新建。创建一个新的集成记录，启用 TOKEN-BASED AUTHENTICATION 和 TBA: AUTHORIZATION FLOW。记下 CONSUMER KEY 和 CONSUMER SECRET。然后，导航到设置 > 用户/角色 > 访问令牌 > 新建，为所需的用户/角色创建访问令牌，并将其链接到集成记录。记下 TOKEN ID 和 TOKEN SECRET。
配置 Python 脚本: 将提供的 Python 脚本复制到文件中（例如 extract_netsuite_ap.py）。在 NETSUITE_CREDENTIALS 字典中，用您的账户 ID、消费者密钥/密文和令牌 ID/密文填充占位符值。
设置提取参数: 修改脚本中的 START_DATE 和 END_DATE 变量，以定义所需的提取时间窗口。建议从较短的时间段（例如一个月）开始进行初步测试。
执行脚本: 从您的终端运行脚本，命令为：python extract_netsuite_ap.py。该脚本将与 NetSuite 进行身份验证，执行多个 SuiteQL 查询以收集数据，并进行处理。
监控脚本执行: 脚本将向控制台打印进度更新，指示当前正在获取哪个数据集（供应商账单、系统日志、付款等）。请耐心等待，因为对于大量数据，这可能需要几分钟。
检查输出: 成功完成后，脚本将在同一目录下生成一个名为 netsuite_ap_event_log.csv 的 CSV 文件。此文件包含结构化的事件日志。
数据转换逻辑: 脚本会自动将原始 NetSuite 数据转换为所需的事件日志格式。它通过解析系统日志中“审批状态”字段的更改来识别“发票已批准”等活动，并通过比较付款日期和到期日期来计算“已识别逾期付款”等派生事件。
准备上传: 生成的 CSV 文件已格式化，可直接上传到流程挖掘工具。请确保列标题（如 Invoice、ActivityName、EventTime 等）与目标应用程序中预期的架构匹配。

配置

身份验证 (Authentication)：脚本使用基于令牌的身份验证 (TBA) 和 OAuth 1.0，这是 NetSuite 服务器间集成的标准。您必须提供账户 ID、消费者密钥、消费者密文、令牌 ID 和令牌密文。
API 端点 (API Endpoint)：脚本会使用您的账户 ID 自动构建 REST API 端点 URL。请确保您的 NetSuite 账户已配置为允许 REST Web 服务请求。
日期范围 (Date Range)：数据抽取由 START_DATE 和 END_DATE 变量控制。为了确保高效检索数据并避免超时，对主查询进行筛选时，务必使用像 lastmodifieddate 或 datecreated 这样的索引日期字段。
数据筛选 (Data Filters)：SuiteQL 查询可通过添加 WHERE 子句（例如 WHERE subsidiary = 'YourSubsidiaryID'）进行定制，以筛选特定子公司、供应商或文档类型。
性能考量 (Performance Considerations)：NetSuite 施加了 API 治理限制。脚本使用分页（LIMIT 和 OFFSET）来妥善处理大型数据集。对于数百万条记录，建议将抽取任务分解为更小的日期块，并分批运行。
前提条件 (Prerequisites)：与访问令牌关联的角色需要对以下记录类型拥有查看权限：供应商账单、供应商付款、供应商贷项、采购订单、系统备注、供应商和员工。

a 查询示例 python

`python
import pandas as pd
import requests
from requests_oauthlib import OAuth1
import time
import datetime
import json

class=class="hl-string">"hl-comment"># --- Configuration ---
class=class="hl-string">"hl-comment"># Replace with your NetSuite Token-Based Authentication credentials
NETSUITE_CREDENTIALS = {
    class="hl-string">"account": class="hl-string">"[Your_NetSuite_Account_ID]", class=class="hl-string">"hl-comment"># e.g., 1234567_SB1
    class="hl-string">"consumer_key": class="hl-string">"[Your_Consumer_Key]",
    class="hl-string">"consumer_secret": class="hl-string">"[Your_Consumer_Secret]",
    class="hl-string">"token_id": class="hl-string">"[Your_Token_ID]",
    class="hl-string">"token_secret": class="hl-string">"[Your_Token_Secret]"
}

class=class="hl-string">"hl-comment"># Set the date range for the extraction
START_DATE = class="hl-string">'2023-01-01'
END_DATE = class="hl-string">'2023-12-31'

class=class="hl-string">"hl-comment"># --- NetSuite API Client ---
def get_netsuite_api_url(account_id):
    class=class="hl-string">"hl-comment"># Replace class="hl-string">'-' with class="hl-string">'_' for sandbox/release preview accounts
    account_id_formatted = account_id.replace(class="hl-string">'-', class="hl-string">'_').lower()
    return fclass="hl-string">"https://{account_id_formatted}.suitetalk.api.netsuite.com/services/rest/query/v1/suiteql"

def execute_suiteql(query):
    class="hl-string">"""Executes a SuiteQL query against the NetSuite REST API with pagination."""
    url = get_netsuite_api_url(NETSUITE_CREDENTIALS[class="hl-string">"account"])
    auth = OAuth1(
        client_key=NETSUITE_CREDENTIALS[class="hl-string">"consumer_key"],
        client_secret=NETSUITE_CREDENTIALS[class="hl-string">"consumer_secret"],
        resource_owner_key=NETSUITE_CREDENTIALS[class="hl-string">"token_id"],
        resource_owner_secret=NETSUITE_CREDENTIALS[class="hl-string">"token_secret"],
        realm=NETSUITE_CREDENTIALS[class="hl-string">"account"]
    )
    headers = {
        class="hl-string">'Content-Type': class="hl-string">'application/json',
        class="hl-string">'Prefer': class="hl-string">'transient'
    }
    
    all_results = []
    offset = 0
    limit = 1000 class=class="hl-string">"hl-comment"># Max limit per page

    while True:
        paginated_query = fclass="hl-string">"{query} LIMIT {limit} OFFSET {offset}"
        payload = json.dumps({class="hl-string">'q': paginated_query})
        
        try:
            response = requests.post(url, headers=headers, data=payload, auth=auth)
            response.raise_for_status() class=class="hl-string">"hl-comment"># Raise an exception for bad status codes
            
            data = response.json()
            items = data.get(class="hl-string">'items', [])
            all_results.extend(items)
            
            if not data.get(class="hl-string">'hasMore', False):
                break
            
            offset += limit
            print(fclass="hl-string">"Fetched {len(all_results)} records...")
            time.sleep(1) class=class="hl-string">"hl-comment"># Be respectful to the API

        except requests.exceptions.RequestException as e:
            print(fclass="hl-string">"API Request Error: {e}")
            if e.response is not None:
                print(fclass="hl-string">"Response Body: {e.response.text}")
            break

    return pd.DataFrame(all_results)

class=class="hl-string">"hl-comment"># --- Main Extraction Logic ---
def main():
    print(class="hl-string">"Starting NetSuite AP Data Extraction...")
    
    class=class="hl-string">"hl-comment"># 1. Fetch Vendor Bills
    print(class="hl-string">"\n--- Step 1: Fetching Vendor Bills ---")
    vendor_bill_query = fclass="hl-string">"""
        SELECT
            tran.ID as TransactionId,
            tran.tranId as Invoice,
            tran.entity as VendorId,
            BUILTIN.DF(tran.entity) as VendorName,
            tran.tranDate as TransactionDate,
            tran.dueDate as InvoiceDueDate,
            tran.createdDate as CreatedDate,
            tran.lastModifiedDate as LastDataUpdate,
            tran.total as InvoiceAmount,
            BUILTIN.DF(tran.createdBy) as ProcessorUser,
            BUILTIN.DF(tran.approvalStatus) as ApprovalStatusText,
            tran.approvalStatus as ApprovalStatusId,
            tran.status as StatusId,
            tran.terms as TermsId,
            BUILTIN.DF(tran.terms) as TermsName
        FROM
            Transaction AS tran
        WHERE
            tran.type = 'VendBill'
            AND tran.lastModifiedDate BETWEEN TO_DATE('{START_DATE}', 'YYYY-MM-DD') AND TO_DATE('{END_DATE}', 'YYYY-MM-DD')
    """
    df_bills = execute_suiteql(vendor_bill_query)
    if df_bills.empty:
        print(class="hl-string">"No vendor bills found for the specified date range. Exiting.")
        return
    
    bill_ids = class="hl-string">','.join(df_bills[class="hl-string">'TransactionId'].astype(str).tolist())
    print(fclass="hl-string">"Found {len(df_bills)} vendor bills.")

    class=class="hl-string">"hl-comment"># 2. Fetch System Notes for status changes
    print(class="hl-string">"\n--- Step 2: Fetching System Notes for status changes ---")
    system_notes_query = fclass="hl-string">"""
        SELECT
            transactionId,
            field,
            newValue,
            oldValue,
            date as EventTime
        FROM
            SystemNote
        WHERE
            transactionId IN ({bill_ids})
            AND field IN ('transaction.approvalstatus', 'transaction.status')
    """
    df_notes = execute_suiteql(system_notes_query)
    print(fclass="hl-string">"Found {len(df_notes)} relevant system notes.")

    class=class="hl-string">"hl-comment"># 3. Fetch PO Links
    print(class="hl-string">"\n--- Step 3: Fetching Purchase Order Links ---")
    po_link_query = fclass="hl-string">"""
        SELECT DISTINCT
            vb.ID as BillId,
            po.tranId as PurchaseOrderNumber
        FROM
            Transaction AS vb
            JOIN TransactionLine AS vbl ON vb.ID = vbl.Transaction
            JOIN Transaction AS po ON vbl.purchaseOrder = po.ID
        WHERE
            vb.ID IN ({bill_ids})
    """
    df_po = execute_suiteql(po_link_query)
    df_po.rename(columns={class="hl-string">'BillId': class="hl-string">'TransactionId'}, inplace=True)
    print(fclass="hl-string">"Found {len(df_po)} PO links.")

    class=class="hl-string">"hl-comment"># 4. Fetch Payments
    print(class="hl-string">"\n--- Step 4: Fetching Payment Information ---")
    payment_query = fclass="hl-string">"""
        SELECT
            link.prevtranid AS BillId,
            pymt.tranDate AS PaymentDate,
            pymt.ID AS PaymentId
        FROM
            NextTransactionLineLink AS link
            JOIN Transaction AS pymt ON link.nexttranid = pymt.ID
        WHERE
            link.prevtranid IN ({bill_ids})
            AND pymt.type = 'VendPymt'
    """
    df_payments = execute_suiteql(payment_query)
    df_payments.rename(columns={class="hl-string">'BillId': class="hl-string">'TransactionId'}, inplace=True)
    print(fclass="hl-string">"Found {len(df_payments)} payment applications.")

    class=class="hl-string">"hl-comment"># 5. Fetch Credit Memo Applications
    print(class="hl-string">"\n--- Step 5: Fetching Credit Memo Applications ---")
    credit_query = fclass="hl-string">"""
        SELECT
            link.prevtranid AS BillId,
            credit.tranDate AS CreditApplyDate
        FROM
            NextTransactionLineLink AS link
            JOIN Transaction AS credit ON link.nexttranid = credit.ID
        WHERE
            link.prevtranid IN ({bill_ids})
            AND credit.type = 'VendCred'
    """
    df_credits = execute_suiteql(credit_query)
    df_credits.rename(columns={class="hl-string">'BillId': class="hl-string">'TransactionId'}, inplace=True)
    print(fclass="hl-string">"Found {len(df_credits)} credit memo applications.")

    class=class="hl-string">"hl-comment"># --- Event Log Generation ---
    print(class="hl-string">"\n--- Step 6: Generating Event Log ---")
    event_log = []
    source_system = class="hl-string">"NetSuite SuiteTalk API"

    for _, bill in df_bills.iterrows():
        base_event = {
            class="hl-string">'Invoice': bill[class="hl-string">'Invoice'],
            class="hl-string">'SourceSystem': source_system,
            class="hl-string">'LastDataUpdate': bill[class="hl-string">'LastDataUpdate'],
            class="hl-string">'VendorName': bill[class="hl-string">'VendorName'],
            class="hl-string">'InvoiceAmount': bill[class="hl-string">'InvoiceAmount'],
            class="hl-string">'InvoiceDueDate': bill[class="hl-string">'InvoiceDueDate'],
            class="hl-string">'ProcessorUser': bill[class="hl-string">'ProcessorUser'],
            class="hl-string">'Approver': None, class=class="hl-string">"hl-comment"># Placeholder, can be enriched from workflow data if available
        }

        po_info = df_po[df_po[class="hl-string">'TransactionId'] == bill[class="hl-string">'TransactionId']]
        base_event[class="hl-string">'PurchaseOrderNumber'] = po_info[class="hl-string">'PurchaseOrderNumber'].iloc[0] if not po_info.empty else None

        class=class="hl-string">"hl-comment"># Activity: Vendor Bill Created
        event_log.append({**base_event, class="hl-string">'ActivityName': class="hl-string">'Vendor Bill Created', class="hl-string">'EventTime': bill[class="hl-string">'CreatedDate']})

        class=class="hl-string">"hl-comment"># Activity: PO Matching Attempted (inferred at creation if PO exists)
        if base_event[class="hl-string">'PurchaseOrderNumber'] is not None:
            event_log.append({**base_event, class="hl-string">'ActivityName': class="hl-string">'PO Matching Attempted', class="hl-string">'EventTime': bill[class="hl-string">'CreatedDate']})

        class=class="hl-string">"hl-comment"># Activities from System Notes
        notes = df_notes[df_notes[class="hl-string">'transactionId'] == bill[class="hl-string">'TransactionId']].sort_values(class="hl-string">'EventTime')
        for _, note in notes.iterrows():
            activity = None
            if note[class="hl-string">'field'] == class="hl-string">'transaction.approvalstatus':
                if note[class="hl-string">'newValue'] == class="hl-string">'Pending Approval': activity = class="hl-string">'Approval Submitted'
                elif note[class="hl-string">'newValue'] == class="hl-string">'Approved': 
                    activity = class="hl-string">'Invoice Approved'
                    event_log.append({**base_event, class="hl-string">'ActivityName': class="hl-string">'Invoice Posted To GL', class="hl-string">'EventTime': note[class="hl-string">'EventTime']})
                elif note[class="hl-string">'newValue'] == class="hl-string">'Rejected': activity = class="hl-string">'Invoice Rejected'
                elif note[class="hl-string">'oldValue'] == class="hl-string">'Pending Approval' and note[class="hl-string">'newValue'] != class="hl-string">'Approved': activity = class="hl-string">'Invoice Re-Routed For Approval'
            
            if note[class="hl-string">'field'] == class="hl-string">'transaction.status' and note[class="hl-string">'newValue'] == class="hl-string">'Paid In Full':
                activity = class="hl-string">'Invoice Closed'

            class=class="hl-string">"hl-comment"># Logic for discrepancy is highly custom. We infer it from a move to a non-standard approval status like class="hl-string">'On Hold'.
            class=class="hl-string">"hl-comment"># This requires knowing the specific numeric ID for such a status.
            class=class="hl-string">"hl-comment"># Example: elif note[class="hl-string">'field'] == class="hl-string">'transaction.approvalstatus' and note[class="hl-string">'newValueId'] == class="hl-string">'[Your_On_Hold_Status_ID]': activity = class="hl-string">'Discrepancy Identified'

            if activity:
                event_log.append({**base_event, class="hl-string">'ActivityName': activity, class="hl-string">'EventTime': note[class="hl-string">'EventTime']})

        class=class="hl-string">"hl-comment"># Payment Activities
        payments = df_payments[df_payments[class="hl-string">'TransactionId'] == bill[class="hl-string">'TransactionId']]
        if not payments.empty:
            first_payment = payments.sort_values(class="hl-string">'PaymentDate').iloc[0]
            event_log.append({**base_event, class="hl-string">'ActivityName': class="hl-string">'Payment Scheduled', class="hl-string">'EventTime': first_payment[class="hl-string">'PaymentDate']}) class=class="hl-string">"hl-comment"># Simplified: using payment date for schedule
            event_log.append({**base_event, class="hl-string">'ActivityName': class="hl-string">'Payment Executed', class="hl-string">'EventTime': first_payment[class="hl-string">'PaymentDate']})

            class=class="hl-string">"hl-comment"># Derived Payment Events
            payment_date = pd.to_datetime(first_payment[class="hl-string">'PaymentDate'])
            due_date = pd.to_datetime(bill[class="hl-string">'InvoiceDueDate'])
            if due_date and payment_date > due_date:
                event_log.append({**base_event, class="hl-string">'ActivityName': class="hl-string">'Late Payment Identified', class="hl-string">'EventTime': first_payment[class="hl-string">'PaymentDate']})
            
            class=class="hl-string">"hl-comment"># Early payment requires discount date from terms, which needs another join. Simplified for this example.
            class=class="hl-string">"hl-comment"># If you query class="hl-string">'discountdate' from the transaction you can compare it here.
            class=class="hl-string">"hl-comment"># For example: if pd.to_datetime(bill[class="hl-string">'discountdate']) and payment_date <= pd.to_datetime(bill[class="hl-string">'discountdate']):
            class=class="hl-string">"hl-comment">#    event_log.append({**base_event, class="hl-string">'ActivityName': class="hl-string">'Early Payment Captured', class="hl-string">'EventTime': first_payment[class="hl-string">'PaymentDate']})

        class=class="hl-string">"hl-comment"># Credit Memo Activity
        credits = df_credits[df_credits[class="hl-string">'TransactionId'] == bill[class="hl-string">'TransactionId']]
        for _, credit in credits.iterrows():
            event_log.append({**base_event, class="hl-string">'ActivityName': class="hl-string">'Credit Memo Applied', class="hl-string">'EventTime': credit[class="hl-string">'CreditApplyDate']})

    class=class="hl-string">"hl-comment"># Finalize DataFrame
    df_event_log = pd.DataFrame(event_log)
    df_event_log.sort_values(by=[class="hl-string">'Invoice', class="hl-string">'EventTime'], inplace=True)
    
    class=class="hl-string">"hl-comment"># Save to CSV
    output_filename = class="hl-string">'netsuite_ap_event_log.csv'
    df_event_log.to_csv(output_filename, index=False)
    print(fclass="hl-string">"\nExtraction complete. Event log saved to {output_filename}")

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

`

步骤

启用SuiteScript：导航至Setup > Company > Enable Features。在SuiteCloud标签页下，确保Server SuiteScript已启用。
创建脚本文件：复制下方query部分完整的JavaScript代码，并将其保存为.js文件（例如，processmind_ap_extraction.js）。
将脚本上传至文件柜：在NetSuite中，前往Documents > Files > SuiteScripts。创建一个新文件夹（例如，ProcessMind），然后上传您创建的.js文件。
创建脚本记录：导航至Customization > Scripting > Scripts > New。选择您刚刚上传的文件，并点击Create Script Record。为脚本命名（例如，"ProcessMind AP Extraction"），提供一个ID（例如，_pm_ap_extraction），然后保存。
定义脚本参数：在脚本记录页面，进入Parameters子标签页。创建以下参数：
- custscript_pm_start_date：标签Start Date，类型Date。
- custscript_pm_end_date：标签End Date，类型Date。
- custscript_pm_folder_id：标签Target Folder ID，类型Integer Number。这是用于保存输出的文件柜内部ID。
- custscript_pm_subsidiary_id：标签Subsidiary ID (Optional)，类型Integer Number。
部署脚本：在脚本记录页面，点击Deploy Script按钮。选择Scheduled Script，然后点击Save。
配置部署：在Script Deployment页面，为部署指定一个ID（例如，_pm_ap_extraction_deployment）。将Status设置为Not Scheduled以便进行初步测试。
设置时间表：在Schedule子标签页下，配置提取的频率。对于首次运行，您可以将其设置为手动运行一次。对于持续提取，则在非高峰时段设置每日或每周的时间表。
设置执行参数：在部署的Parameters子标签页，输入所需的Start Date、End Date和Target Folder ID以进行提取。
执行并检索文件：要手动运行，请将部署的Status设置为Not Scheduled并保存，然后点击Save and Execute。在Customization > Scripting > Script Execution Logs下监控脚本进度。完成后，导航至文件柜中的目标文件夹以下载生成的CSV事件日志。
为ProcessMind格式化：确保下载的CSV文件具有脚本中指定的正确标题（Invoice、ActivityName、EventTime等）。该文件现已准备好上传到ProcessMind。

配置

前提条件 (Prerequisites)：需要具备创建和执行 SuiteScripts 的权限，以及访问供应商账单和供应商付款记录、查看系统备注的 NetSuite 用户角色。
脚本参数 (Script Parameters)：脚本可通过部署参数进行配置，从而无需更改代码即可重复使用：
- 开始日期 (Start Date) 和结束日期 (End Date)：根据发票的创建日期定义处理周期。对于初始加载，建议使用 6-12 个月的周期。对于后续的增量加载，可以设置为最近 7 天。
- 目标文件夹 ID (Target Folder ID)：指定 NetSuite File Cabinet 文件夹的内部 ID，输出的 CSV 文件将存储在该文件夹中。该文件夹必须事先创建。
- 子公司 ID (可选) (Subsidiary ID (Optional)): 在 OneWorld 账户中，此参数用于将数据抽取筛选至特定子公司。留空则表示运行用户可访问的所有子公司的数据。
性能考量 (Performance Considerations)：对于交易量大的环境（每月超过 50,000 份发票），Map/Reduce script 可能更适合，以避免超出治理限制。建议在非工作时间运行脚本，以最大程度地减少对性能的影响。
自定义字段 (Custom Fields)：如果您的审批流程或其他关键数据点依赖于自定义字段或记录，则脚本中的 Saved Search 过滤器和列必须进行调整，以包含这些自定义元素的内部 ID。

a 查询示例 javascript

`javascript
/**
 * @NApiVersion 2.1
 * @NScriptType ScheduledScript
 * @NModuleScope SameAccount
 */

/*

ProcessMind NetSuite AP Invoice Extraction Script

This script extracts Accounts Payable invoice processing events from NetSuite.
It queries Vendor Bill and related transaction data, formats it into a single event log, and saves it as a CSV file in the File Cabinet.

Script Parameters:
- custscript_pm_start_date: (Date) The start date for the query window (based on bill creation date).
- custscript_pm_end_date: (Date) The end date for the query window.
- custscript_pm_folder_id: (Integer) The internal ID of the File Cabinet folder to save the CSV file in.
- custscript_pm_subsidiary_id: (Integer, Optional) The internal ID of the subsidiary to filter on.

*/

define(['N/search', 'N/runtime', 'N/file', 'N/format', 'N/log'], (search, runtime, file, format, log) => {

    const execute = (context) => {
        log.debug('Script Execution Started', 'Starting AP Invoice event log extraction.');

        const script = runtime.getCurrentScript();
        const startDate = script.getParameter({ name: 'custscript_pm_start_date' });
        const endDate = script.getParameter({ name: 'custscript_pm_end_date' });
        const folderId = script.getParameter({ name: 'custscript_pm_folder_id' });
        const subsidiaryId = script.getParameter({ name: 'custscript_pm_subsidiary_id' });

        if (!startDate || !endDate || !folderId) {
            log.error('Missing Parameters', 'Start Date, End Date, and Folder ID are required.');
            return;
        }

        let allEvents = [];
        const now = new Date();

        // Helper to format date/time for CSV
        const formatDateTime = (dateStr) => {
            if (!dateStr) return '';
            try {
                const parsedDate = format.parse({ value: dateStr, type: format.Type.DATETIME });
                return format.format({ value: parsedDate, type: format.Type.DATETIMETZ });
            } catch (e) {
                return dateStr; // Fallback for simple date strings
            }
        };

        // Helper function to run a search and format results
        const runSearchAndCollectEvents = (config) => {
            log.debug('Running Search', Activity: ${config.activityName});
            const searchObj = search.create({
                type: config.type,
                filters: config.filters,
                columns: config.columns
            });

            const pagedData = searchObj.runPaged({ pageSize: 1000 });
            pagedData.pageRanges.forEach(pageRange => {
                const page = pagedData.fetch({ index: pageRange.index });
                page.data.forEach(result => {
                    allEvents.push({
                        'Invoice': result.getValue(config.mapping.Invoice) || '',
                        'ActivityName': config.activityName,
                        'EventTime': formatDateTime(result.getValue(config.mapping.EventTime)) || '',
                        'SourceSystem': 'NetSuite',
                        'LastDataUpdate': format.format({ value: now, type: format.Type.DATETIMETZ }),
                        'VendorName': result.getText(config.mapping.VendorName) || result.getValue(config.mapping.VendorName) || '',
                        'InvoiceAmount': result.getValue(config.mapping.InvoiceAmount) || '',
                        'PurchaseOrderNumber': result.getText(config.mapping.PurchaseOrderNumber) || result.getValue(config.mapping.PurchaseOrderNumber) || '',
                        'ProcessorUser': result.getText(config.mapping.ProcessorUser) || '',
                        'Approver': result.getText(config.mapping.Approver) || '',
                        'InvoiceDueDate': result.getValue(config.mapping.InvoiceDueDate) || ''
                    });
                });
            });
            log.debug('Search Complete', Found ${allEvents.length} total events so far.);
        };

        // Common filters
        let baseBillFilters = [
            ['mainline', 'is', 'T'], 'AND',
            ['type', 'anyof', 'VendBill'], 'AND',
            ['datecreated', 'within', startDate, endDate]
        ];
        if (subsidiaryId) {
            baseBillFilters.push('AND', ['subsidiary', 'anyof', subsidiaryId]);
        }

        // --- Define Search Configurations for each Activity ---

        const searchConfigs = [
            // 1. Vendor Bill Created
            {
                activityName: 'Vendor Bill Created',
                type: 'vendorbill',
                filters: baseBillFilters,
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'datecreated', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'createdby', label: 'ProcessorUser' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: 'datecreated', VendorName: 'entity', InvoiceAmount: 'total', ProcessorUser: 'createdby', InvoiceDueDate: 'duedate' }
            },
            // 2. PO Matching Attempted (Inferred from System Notes on first PO application)
            {
                activityName: 'PO Matching Attempted',
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['systemnotes.field', 'is', 'appliedtotransaction'], 'AND', ['systemnotes.newvalue', 'contains', 'Purchase Order']]),
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'date', join: 'systemNotes', sort: search.Sort.ASC, label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'createdby', label: 'ProcessorUser' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' }),
                    search.createColumn({ name: 'appliedtotransaction', label: 'PurchaseOrderNumber' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'date', join: 'systemNotes'}), VendorName: 'entity', InvoiceAmount: 'total', ProcessorUser: 'createdby', InvoiceDueDate: 'duedate', PurchaseOrderNumber: 'appliedtotransaction' }
            },
            // 3. Discrepancy Identified (Uses a placeholder for custom status, e.g., 'On Hold')
            {
                activityName: 'Discrepancy Identified',
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['systemnotes.field', 'is', 'approvalstatus'], 'AND', ['systemnotes.newvalue', 'is', '[On Hold]']]), // Placeholder: Replace '[On Hold]' with your actual status text
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'date', join: 'systemNotes', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'name', join: 'systemNotes', label: 'ProcessorUser' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'date', join: 'systemNotes'}), VendorName: 'entity', InvoiceAmount: 'total', ProcessorUser: search.createColumn({name: 'name', join: 'systemNotes'}), InvoiceDueDate: 'duedate' }
            },
            // 4. Approval Submitted & 5. Invoice Re-Routed For Approval
            {
                activityName: 'Approval Submitted', // This will capture initial and subsequent submissions
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['systemnotes.field', 'is', 'approvalstatus'], 'AND', ['systemnotes.newvalue', 'is', 'Pending Approval']]),
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'date', join: 'systemNotes', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'name', join: 'systemNotes', label: 'ProcessorUser' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'date', join: 'systemNotes'}), VendorName: 'entity', InvoiceAmount: 'total', ProcessorUser: search.createColumn({name: 'name', join: 'systemNotes'}), InvoiceDueDate: 'duedate' }
            },
            // 6. Invoice Approved & 8. Invoice Posted to GL
            {
                activityName: 'Invoice Approved', // Approval event often coincides with posting
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['systemnotes.field', 'is', 'approvalstatus'], 'AND', ['systemnotes.newvalue', 'is', 'Approved']]),
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'date', join: 'systemNotes', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'name', join: 'systemNotes', label: 'Approver' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'date', join: 'systemNotes'}), VendorName: 'entity', InvoiceAmount: 'total', Approver: search.createColumn({name: 'name', join: 'systemNotes'}), InvoiceDueDate: 'duedate' }
            },
            // 7. Invoice Rejected
            {
                activityName: 'Invoice Rejected',
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['systemnotes.field', 'is', 'approvalstatus'], 'AND', ['systemnotes.newvalue', 'is', 'Rejected']]),
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'date', join: 'systemNotes', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'name', join: 'systemNotes', label: 'Approver' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'date', join: 'systemNotes'}), VendorName: 'entity', InvoiceAmount: 'total', Approver: search.createColumn({name: 'name', join: 'systemNotes'}), InvoiceDueDate: 'duedate' }
            },
            // 9. Payment Scheduled
            {
                activityName: 'Payment Scheduled',
                type: 'vendorpayment',
                filters: [['mainline', 'is', 'T'], 'AND', ['type', 'anyof', 'VendPymt'], 'AND', ['appliedtotransaction.type', 'anyof', 'VendBill'], 'AND', ['appliedToTransaction.datecreated', 'within', startDate, endDate]],
                columns: [
                    search.createColumn({ name: 'tranid', join: 'appliedToTransaction', label: 'Invoice' }),
                    search.createColumn({ name: 'datecreated', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', join: 'appliedToTransaction', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'createdby', label: 'ProcessorUser' }),
                    search.createColumn({ name: 'duedate', join: 'appliedToTransaction', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: search.createColumn({name: 'tranid', join: 'appliedToTransaction'}), EventTime: 'datecreated', VendorName: 'entity', InvoiceAmount: search.createColumn({name: 'total', join: 'appliedToTransaction'}), ProcessorUser: 'createdby', InvoiceDueDate: search.createColumn({name: 'duedate', join: 'appliedToTransaction'}) }
            },
            // 10. Payment Executed
            {
                activityName: 'Payment Executed',
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['payingtransaction.trandate', 'isnotempty', '']]),
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'trandate', join: 'payingTransaction', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'createdby', join: 'payingTransaction', label: 'ProcessorUser' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'trandate', join: 'payingTransaction'}), VendorName: 'entity', InvoiceAmount: 'total', ProcessorUser: search.createColumn({name: 'createdby', join: 'payingTransaction'}), InvoiceDueDate: 'duedate' }
            },
            // 11. Invoice Closed
            {
                activityName: 'Invoice Closed',
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['systemnotes.field', 'is', 'Status'], 'AND', ['systemnotes.newvalue', 'is', 'Vendor Bill : Paid in Full']]),
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'date', join: 'systemNotes', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'name', join: 'systemNotes', label: 'ProcessorUser' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'date', join: 'systemNotes'}), VendorName: 'entity', InvoiceAmount: 'total', ProcessorUser: search.createColumn({name: 'name', join: 'systemNotes'}), InvoiceDueDate: 'duedate' }
            },
            // 12. Early Payment Captured
            {
                activityName: 'Early Payment Captured',
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['payingtransaction.trandate', 'isnotempty', ''], 'AND', ['formuladate: {payingtransaction.trandate} <= {discountdate}', 'is', '1']]),
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'trandate', join: 'payingTransaction', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'trandate', join: 'payingTransaction'}), VendorName: 'entity', InvoiceAmount: 'total', InvoiceDueDate: 'duedate' }
            },
            // 13. Late Payment Identified
            {
                activityName: 'Late Payment Identified',
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['payingtransaction.trandate', 'isnotempty', ''], 'AND', ['formuladate: {payingtransaction.trandate} > {duedate}', 'is', '1']]),
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'trandate', join: 'payingTransaction', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'trandate', join: 'payingTransaction'}), VendorName: 'entity', InvoiceAmount: 'total', InvoiceDueDate: 'duedate' }
            },
            // 14. Credit Memo Applied
            {
                activityName: 'Credit Memo Applied',
                type: 'vendorbill',
                filters: baseBillFilters.concat(['AND', ['applyingtransaction.type', 'anyof', 'VendCred']]),
                columns: [
                    search.createColumn({ name: 'tranid', label: 'Invoice' }),
                    search.createColumn({ name: 'trandate', join: 'applyingTransaction', label: 'EventTime' }),
                    search.createColumn({ name: 'entity', label: 'VendorName' }),
                    search.createColumn({ name: 'total', label: 'InvoiceAmount' }),
                    search.createColumn({ name: 'createdby', join: 'applyingTransaction', label: 'ProcessorUser' }),
                    search.createColumn({ name: 'duedate', label: 'InvoiceDueDate' })
                ],
                mapping: { Invoice: 'tranid', EventTime: search.createColumn({name: 'trandate', join: 'applyingTransaction'}), VendorName: 'entity', InvoiceAmount: 'total', ProcessorUser: search.createColumn({name: 'createdby', join: 'applyingTransaction'}), InvoiceDueDate: 'duedate' }
            },
        ];

        // Execute all searches
        searchConfigs.forEach(config => {
            try {
                runSearchAndCollectEvents(config);
            } catch (e) {
                log.error(Search Failed for ${config.activityName}, e);
            }
        });

        // Convert to CSV and save
        if (allEvents.length > 0) {
            const headers = Object.keys(allEvents[0]);
            let csvContent = headers.join(',') + '\n';
            allEvents.forEach(event => {
                const row = headers.map(header => {
                    let value = event[header] ? event[header].toString() : '';
                    // Escape commas and quotes
                    if (value.includes(',') || value.includes('"') || value.includes('\n')) {
                        value = '"' + value.replace(/"/g, '""') + '"';
                    }
                    return value;
                });
                csvContent += row.join(',') + '\n';
            });

            const fileName = ProcessMind_AP_EventLog_${new Date().toISOString().slice(0, 10)}.csv;
            const csvFile = file.create({
                name: fileName,
                fileType: file.Type.CSV,
                contents: csvContent,
                folder: folderId
            });
            const fileId = csvFile.save();
            log.audit('File Created', Successfully created file ${fileName} with ID ${fileId} in folder ${folderId}.);
        } else {
            log.audit('No Events Found', 'No events found for the specified criteria.');
        }

        log.debug('Script Execution Finished', Processed a total of ${allEvents.length} events.);
    };

    return { execute };
});
`

数据模板：应付账款发票处理

您的应付账款发票处理数据模板

应付账款发票处理属性

应付账款发票处理活动

提取指南

NetSuite已保存的搜索和标准报告导出

步骤

配置

a 查询示例 config

通过 SuiteAnalytics Connect (ODBC/JDBC) 进行 SuiteQL 查询

步骤

配置

a 查询示例 sql

使用 SuiteTalk REST/SOAP API 的 Python 脚本

步骤

配置

a 查询示例 python

使用服务器端SuiteScript进行自动化数据导出

步骤

配置

a 查询示例 javascript

准备好开始了吗？

掌控全局：即刻优化应付账款发票处理