产品详细信息以英文显示。翻译即将推出。
速览
- 价格
- $249.00 USD
- ERPNext 版本
- —
- 设置时间
- 30分钟
- 许可证
- 一次永久
- 语言
- 11 语言
一次性购买
Timesheet & Project Billing for HR
A build-to-order ERPNext app that bridges attendance and project timesheets into billable hours, project labor cost, and payroll — with an approval workflow and utilization reporting. ECOSIRE scopes, builds, installs, and supports it on your own instance.
$249.00USD
现在无需付款。此操作会向我们的团队发送报价请求——我们会通过邮件跟进价格和后续步骤。
核心功能
Auto-generates draft `Timesheet` records from approved `Attendance` and `Employee Checkin` data via scheduler events and `hooks.py` document events
Reconciles attended hours against logged project hours and flags the variance before billing
Per-line billable vs non-billable classification on `Timesheet Detail`, each carrying its own billing rate and costing rate
Project labor-cost allocation that books logged time against `Project` and `Task` for real-time margin visibility
Frappe Workflow-driven approval path (Draft → Submitted → Approved / Rejected) gated by role profiles and permission rules
Server scripts and controller hooks enforcing daily-hours caps, non-billable code lists, and period locks after payroll cut-off
One-click generation of `Sales Invoice` lines from approved billable timesheet entries at the agreed billing rate
Feeds costing-rate hours into `Salary Slip` so payroll labor cost and project cost reconcile to the same source
Whitelisted methods over the Frappe REST API for external timers, mobile capture, or PSA/Slack integrations
Utilization and capacity Query Reports: billable-utilization %, capacity-vs-booked, and project-margin per employee and per project
Configurable rounding and rate-resolution logic (employee rate → project rate → customer rate precedence)
Client Scripts for in-form validation and quick-entry UX on the `Timesheet` DocType
Role- and permission-scoped visibility so employees see their own time while managers see the whole book
Notifications and dashboard indicators for pending approvals, over-cap days, and unbilled approved hours
关于此产品
Agencies and services firms running ERPNext know their people are their cost of goods sold, but native ERPNext keeps attendance, project timesheets, billing, and payroll in loosely connected silos. Standard Employee Checkin and Attendance prove someone showed up, while the Timesheet DocType records what they worked on — but nothing reconciles the two. A person marked present for 8 hours with only 5 hours of logged tasks slips through unnoticed, billing rates and cost rates live in scattered fields, and finance rebuilds the margin picture in spreadsheets every month. When your profit is the gap between billable hours and paid labor cost, that gap deserves to be a first-class number inside ERPNext, not a manual reconciliation.
为什么选择 Timesheet & Project Billing for HR
Auto-generates draft `Timesheet` records from approved `Attendance` and `Employee Checkin` data via scheduler events and `hooks.py` document events
Reconciles attended hours against logged project hours and flags the variance before billing
Per-line billable vs non-billable classification on `Timesheet Detail`, each carrying its own billing rate and costing rate
Project labor-cost allocation that books logged time against `Project` and `Task` for real-time margin visibility
Frappe Workflow-driven approval path (Draft → Submitted → Approved / Rejected) gated by role profiles and permission rules
Server scripts and controller hooks enforcing daily-hours caps, non-billable code lists, and period locks after payroll cut-off
We build a proper Frappe app — its own module, installed via bench get-app and bench install-app — that layers on top of the native Attendance, Timesheet, Project, Sales Invoice, and Salary Slip DocTypes rather than replacing them. Scheduler events and hooks.py document events (on_submit, validate, on_update) auto-generate draft Timesheet records from approved Attendance and Employee Checkin data, so the workday HR already captured becomes the starting point for project time — and any variance between attended hours and logged hours is surfaced before it reaches billing. Each Timesheet Detail line carries a billable flag, a billing rate, and a costing rate, so the same entry drives both the customer-facing Sales Invoice amount and the internal labor cost booked against the Project.
On top of that we wire a real approval path using Frappe's Workflow engine: time entries move through Draft to Submitted for Approval to Approved (or Rejected back to the employee), gated by role profiles and permission rules so an employee can log time but only a project manager can approve it for billing. Server scripts and controller hooks enforce your business rules — daily-hours caps, non-billable code lists, locked periods after payroll cut-off — and whitelisted methods exposed over the Frappe REST API let a mobile timer, a Slack bot, or an external PSA push entries straight into the workflow. Utilization and capacity reports are built as Query Reports / Report Builder views over the timesheet data, giving you billable-utilization %, capacity-vs-booked, and project-margin figures without an export.
Because this is build-to-order, nothing ships until we agree on scope. We start with a short scoping call, map exactly how your attendance-to-billing chain should behave (rounding rules, approval roles, invoice cadence, which cost flows into Salary Slip), then build the app against Frappe/ERPNext v15/v16, validate it on a staging clone of your instance through UAT, and install it on production with a rollback plan. You receive the full source in a git repository, so you own the code and are never locked to us. Typical delivery is 2–4 weeks from confirmed scope, and we stay on through a post-go-live support window.
你得到什么
- Installable source code for your version of the app, delivered as a proper Frappe app (`bench get-app` / `bench install-app`)
- Installation and configuration on your ERPNext instance, including workflow, roles, and rate rules
- Technical documentation: DocType and field reference, hooks/server-script logic, REST endpoints, and scheduler events
- User guide plus a live training session for approvers, project managers, and time-logging staff
- UAT on a staging clone of your instance with a documented rollback plan before production install
- Post-go-live support window for defect fixes and configuration adjustments
- Handover of the full git repository so you own and can extend the code
- Compatibility validation against your Frappe/ERPNext v15 or v16 release
这是给谁的
Agency / services-firm owner
Runs a project-based business on ERPNext and needs an honest margin per project — knowing exactly how billable hours compare to the labor cost paid out, without waiting for a month-end spreadsheet.
Project / delivery manager
Owns utilization and delivery. Needs to approve time entries, see capacity-vs-booked for the team, and catch non-billable creep before it eats the project budget.
Finance / payroll lead
Needs the same hours to flow to both `Sales Invoice` and `Salary Slip` so billing and payroll cost reconcile, with locked periods after cut-off and a clean audit trail on every approval.
HR / operations manager
Already captures attendance in ERPNext and wants that data to seed timesheets automatically, eliminating double entry and reconciling who was present against who logged their time.
安装概述
从ECOSIRE下载
在 ecosire.com 上购买许可证并从您的帐户仪表板下载 Timesheet & Project Billing for HR 应用程序 ZIP。
将应用程序添加到您的工作台
将 ZIP 解压到您的 bench 的 apps 文件夹中，或者使用解压缩的应用程序的路径运行“bench get-app”。
安装在您的网站上
运行 `bench --site SITE_NAME install-app APP_NAME`，然后运行 `bench migrate` 以安装 Timesheet & Project Billing for HR 并应用其架构。
激活您的许可证
打开您站点上的 ECOSIRE 许可证设置并激活您的许可证密钥。需要免费的 ecosire_connect 和 ecosire_license_client 应用程序。
Timesheet & Project Billing for HR 如何比较
| 标准 | 伊科西尔 | 定制建造 | 竞争对手 | 奥杜本机 |
|---|---|---|---|---|
| Attendance-to-timesheet link | Auto-drafts timesheets from attendance and flags hour variance | Possible, but you build and maintain the sync logic | Rarely bridges attendance; timesheet-only | |
| Billable vs non-billable + dual rates | Per-line billing rate and costing rate driving invoice and cost | Whatever you spec and code yourself | Basic billable flag, limited cost-rate handling | |
| Approval workflow | Frappe Workflow with your roles, caps, and period locks | Build the workflow and permission rules from scratch | Fixed workflow you adapt to, not the reverse | |
| Project cost & margin | Logged time booked to project with utilization/margin reports | Custom reports you design and maintain | Generic reports, often not project-margin aware | |
| External integration | Whitelisted REST methods scoped and documented for your tools | You design and secure the API surface | Fixed or no integration hooks | |
| Fit to your process | Built to your rounding, roles, and billing cadence | Fully bespoke — highest effort and cost to reach | You bend your process to the app's assumptions | |
| Ownership & lock-in | Full git repo handover; you own and can extend it | You own it, but carry all build risk | Vendor-licensed; limited or no source access | |
| Upgrade safety | Separate app via hooks; survives v15/v16 upgrades | Depends on how disciplined the build is | Varies; some patch core and break on upgrade |
关于Timesheet & Project Billing for HR的常见问题
+Is this a ready-made app I can download and install today?
No. This is build-to-order. ECOSIRE scopes, builds, installs, and supports the app for your specific ERPNext instance — there is no instant download. You get source code tailored to your rate rules, approval roles, and billing cadence, delivered as a proper Frappe app you own.
+How long does delivery take?
Typically 2–4 weeks from confirmed scope. After a short scoping call we agree exactly how your attendance-to-billing chain should behave, then build, run UAT on a staging clone, and install on production. Complex integrations or unusual payroll rules can extend the timeline, and we tell you before you commit.
+Which ERPNext versions do you support, and what about updates?
We build and validate against Frappe/ERPNext v15 and v16. Because the app layers on native DocTypes via `hooks.py` and whitelisted methods rather than patching core, it survives ERPNext upgrades cleanly. A post-go-live support window covers defect fixes and config adjustments; longer-term maintenance and version bumps are available as a separate agreement.
+Will it modify or break ERPNext core?
No. It is a separate Frappe app in its own module. It extends `Attendance`, `Timesheet`, `Project`, `Sales Invoice`, and `Salary Slip` through document events, server scripts, client scripts, and custom fields — never by editing core files — so your instance stays upgrade-safe and the app can be uninstalled cleanly.
+Do we own the code, or are we locked in?
You own it. We hand over the full git repository at delivery, so your team (or any Frappe developer) can read, extend, and maintain it. There is no license lock and no dependency on ECOSIRE to keep running.
+Can it push time in from outside ERPNext?
Yes. We expose whitelisted methods over the Frappe REST API so external timers, a mobile capture app, a Slack bot, or a PSA tool can create timesheet entries that enter the same approval workflow. The exact endpoints and payloads are defined during scoping and documented in the handover.
+How does approval and billing actually work together?
Time entries move through a Frappe Workflow (Draft → Submitted → Approved) gated by role profiles, so only an authorized approver can release hours for billing. Approved billable lines generate `Sales Invoice` amounts at the resolved billing rate, while their costing-rate hours flow into project cost and `Salary Slip` — one source, reconciled.
申请报价
Timesheet & Project Billing for HR
A build-to-order ERPNext app that bridges attendance and project timesheets into billable hours, project labor cost, and payroll — with an approval workflow and utilization reporting. ECOSIRE scopes, builds, installs, and supports it on your own instance.
- Auto-generates draft `Timesheet` records from approved `Attendance` and `Employee Checkin` data via scheduler events and `hooks.py` document events
- Reconciles attended hours against logged project hours and flags the variance before billing
- Per-line billable vs non-billable classification on `Timesheet Detail`, each carrying its own billing rate and costing rate
- Project labor-cost allocation that books logged time against `Project` and `Task` for real-time margin visibility