growerp_manuf_liner 1.1.1

GrowERP liner-panel manufacturing building block (LinerType, LinerPanel, PDF production order)

growerp_manuf_liner

A GrowERP building-block package that extends growerp_manufacturing with liner-panel manufacturing capabilities: a material catalogue (Liner Types), a per-panel QC tracking system (Liner Panels), and a shop-floor production-order PDF generator.

It is designed for factories that cut and seam flexible geomembrane or geotextile materials (pond liners, landfill liners, etc.) where each panel has a distinct width, length, and liner type, and the shop floor needs a printed production order showing the panel list, liner totals, and BOM.

Features

Liner Types — material catalogue

• Define every plastic material used in the factory: name, width increment, roll-stock width, and weight per square foot.
• The weight field drives automatic panel-weight calculations.
• Full CRUD — searchable list, dialog form, delete with confirmation.

Liner Panels — per-panel QC tracking

• Attach an ordered list of panels to any Work Order.
• Each panel captures: panel name, liner type (dropdown), width (ft), and length (ft).
• Computed fields (read-only in the dialog, calculated server-side):
  • panelSqft — width × length
  • passes — how many roll-stock passes are needed given widthIncrement
  • weight — sqft × linerWeight from the chosen Liner Type
• A QC number (qcNum) is auto-assigned by the backend on creation.
• Panels are embedded inside the Work Order dialog via extraTabBuilder, keeping the production context visible at all times.
• Panels can also be filtered by salesOrderId to show only panels for a specific customer order.

Production-order PDF

await printProductionOrder(workOrder);

Generates and previews a formatted PDF containing:

Section	Content
Header	WO #, product, quantity, start date, routing, notes
Panels table	QC#, panel name, liner, width, length, sqft, passes, weight
Liner totals	Total sqft and estimated weight, grouped by liner type
BOM items	Product ID and quantity for each component

Uses the pdf and printing packages.

Architecture

The package follows the GrowERP BLoC pattern:

growerp_manuf_liner/lib/src/
├── liner_type/
│   ├── blocs/        # LinerTypeBloc, LinerTypeEvent, LinerTypeState
│   ├── views/        # LinerTypeList, LinerTypeDialog
│   └── integration_test/  # LinerTypeTest
├── liner_panel/
│   ├── blocs/        # LinerPanelBloc, LinerPanelEvent, LinerPanelState
│   ├── views/        # LinerPanelList, LinerPanelDialog
│   └── integration_test/  # LinerPanelTest
└── production_order/
    └── production_order_pdf.dart   # printProductionOrder()

All backend communication goes through growerp_models REST client endpoints:

Entity	Endpoint
Liner Types	GET/POST/PATCH/DELETE /rest/s1/growerp/100/LinerType(s)
Liner Panels	GET/POST/PATCH/DELETE /rest/s1/growerp/100/LinerPanel(s)

Adding to an App

1. Add the dependency to your pubspec.yaml:

   dependencies:
     growerp_manuf_liner: ^1.0.0
   

2. Register BLoC providers using the helper:

   import 'package:growerp_manuf_liner/growerp_manuf_liner.dart';
   
   blocProviders: [
     ...getManufacturingBlocProviders(restClient),  // from growerp_manufacturing
     ...getLinerBlocProviders(restClient),
     // ... other providers
   ],
   

3. Wire up routes in your router:

   '/liner/linerType'         => const LinerTypeList(),
   '/manufacturing/workOrder' => WorkOrderList(
     extraTabBuilder: (workOrder) => [
       SizedBox(
         height: 300,
         child: LinerPanelList(workEffortId: workOrder.workEffortId),
       ),
     ],
     extraActionBuilder: (workOrder) => [
       IconButton(
         key: const Key('printProductionOrder'),
         icon: const Icon(Icons.print),
         onPressed: () => printProductionOrder(workOrder),
       ),
     ],
   ),
   

4. Add menu items (example):

   MenuItem(title: 'Liner Types',  route: '/liner/linerType',        iconName: 'layers'),
   MenuItem(title: 'Work Orders',  route: '/manufacturing/workOrder', iconName: 'precision_manufacturing'),
   

Integration Tests

All integration tests live in example/integration_test/. Run from the example/ sub-package (requires a running Moqui backend on port 8080 and a connected device/emulator):

cd flutter/packages/growerp_manuf_liner/example
flutter test integration_test/<test-file>.dart \
    -d <device-id> \
    --dart-define=BACKEND_PORT=8080

Focused unit tests

These tests cover the extra functions specific to this package, independent of the full order-accounting lifecycle. Each test creates a fresh company and tears it down on logout.

liner_type_test.dart — LinerType CRUD

Exercises the material catalogue managed by LinerTypeBloc.

Step	Action
Setup	Fresh company + admin created.
1	Navigate to the Liner Types list (/liner/linerType).
2	Add two liner types: 60 mil HDPE (0.306 lb/sqft, 22.5 ft increment) and 40 mil LLDPE (0.204 lb/sqft).
3	Verify both names appear in the list (backend returns newest-first).
4	Open the first item — confirm the LinerTypeDialog opens with pre-filled fields.
5	Delete the first liner type and confirm removal.
Teardown	Logout.

liner_panel_test.dart — LinerPanel with computed fields

Exercises LinerPanelBloc and the auto-calculation of sqft, passes, and weight. Panels are accessed through the Work Order dialog's embedded tab.

Step	Action
Setup	Fresh company + admin, with one product pre-loaded (LINER-SYS-60).
1	Add one liner type (60 mil HDPE) so the panel dialog dropdown is populated.
2	Navigate to Work Orders and create a work order for LINER-SYS-60.
3	Open the work order — the Liner Panels tab is shown via extraTabBuilder.
4	Add Panel A (45 ft × 100 ft) and Panel B (22.5 ft × 50 ft).
5	Verify both panels have a server-assigned qcNum (non-empty).
6	Open Panel A — confirm panelSqft, passes, and weight fields are present.
7	Delete Panel B.
Teardown	Close the Work Order dialog and logout.

End-to-end demo

Demo: Pond Liner System (liner_demo_test.dart)

Full lifecycle — from material setup through production PDF and accounting — using a Pond Liner System 60mil finished good and 60 mil HDPE Roll Stock raw material.

Phase	What happens
Setup	Products, BOM, warehouse location, and trading partners loaded into a fresh company.
1 — Liner Types	Two liner materials defined: 60 mil HDPE and 40 mil LLDPE.
2 — Routing	Standard Liner routing created with four tasks: Cut → Seam → QC Inspection → Fold & Package.
3 — BOM	BOM for Pond Liner System 60mil viewed (1 × Roll Stock pre-loaded).
4 — Sales Order	Customer orders 1 × Pond Liner System. Order approved — Work Order auto-created.
5 — Liner Panels	Work Order opened; routing assigned; two liner panels added (Panel 1: 45×100 ft, Panel 2: 22.5×50 ft). Computed fields verified.
6 — Purchase	Purchase order for 5 rolls of roll stock raised, approved, and paid.
7 — Receive	Incoming shipment approved and received into the warehouse; material shortage cleared.
8 — Production	Work Order released → started → Print button tapped (generates PDF) → completed. Finished good enters stock.
9 — Ship	Outgoing shipment to customer approved and completed; sales payment collected.
10 — Accounting	General ledger reviewed — inventory cost, COGS, revenue, and all payments posted.

Backend

The Moqui services that power this package live in:

moqui/runtime/component/growerp/service/growerp/100/ManufacturingServices100.xml

Key services: get#LinerTypes, create#LinerType, update#LinerType, delete#LinerType, get#LinerPanels, create#LinerPanel (auto-assigns QC number, computes sqft/passes/weight), update#LinerPanel, delete#LinerPanel.

End-User Workflow

In GrowERP, the Liner Manufacturing module is designed specifically for businesses that fabricate large, custom-sized products out of rolled flat materials—for example, swimming pool liners, truck tarpaulins, or industrial geomembranes.

Instead of just tracking generic parts in a Bill of Materials, this module helps you calculate exactly how to cut and assemble the final product from flat sheets.

Here is an end-user explanation of how the workflow operates:

1. Define Your Materials (Liner Types)

First, you set up your Liner Types. This represents the master rolls of raw material you keep in inventory (e.g., "20 mil Blue Vinyl", "Heavy Duty Canvas", or "Clear PVC").

2. Enter Custom Dimensions (Liner Panels)

When you receive an order for a custom liner, you create a Production Order (Work Order). Because material usually comes in fixed-width rolls (like 6 feet wide), a large 20x40 pool liner can't be cut in one piece. It has to be built by welding multiple "panels" together.

You add individual Liner Panels to the order. For each piece you need your shop floor to cut, you specify:

• Liner Type: Which raw material roll to use.
• Dimensions: The specific Width and Length in feet.
• Panel Name (Optional): A friendly name so the shop knows what the piece is for (e.g., "Deep End Wall", "Shallow Floor").

3. Automatic Shop Floor Calculations

As you enter these panels, the system does the heavy lifting for you. It automatically calculates:

• Square Footage (SqFt): The area of each panel to track material consumption.
• Estimated Weight: The weight of each panel and the total weight of the finished product. This is critical for knowing if a liner will be too heavy for a standard pallet or if it requires special shipping logistics.
• Welding/Sewing Passes: It estimates the number of "passes" the shop floor will need to make to seam all these panels together into the final product.

4. Tracking and Quality Control (QC#)

Every single panel you enter is automatically assigned a unique QC# (Quality Control Number). This allows your production team to label every piece as it is cut, ensuring nothing gets lost and everything is welded in the correct order.

5. Generate the Production Document

Finally, you can generate a Printable Production Order (PDF). This acts as the "Traveler" document that you hand to your manufacturing team. It includes:

• Header details (Work Order #, Routing details, Start Date).
• A summary of the total square footage and total weight needed per material type.
• A detailed, row-by-row table showing every single panel to be cut, including its QC#, dimensions, and material type, so the floor workers know exactly what to produce.