Source-derived document; reported behaviour, inference and evidence gaps are identified in the text.

02 — Business Capability Map

Diagram coverage

Capability structure and application variants

The evidence describes a menu-driven order-management domain for customers, orders, stock, states, invoices, and reports. In the current Java application, D4_Main starts the com.ais.demo module, connects through the stores7 database alias, loads shared state, and exposes Customer, Orders, Stock, Reports, and Exit commands. The application is presented as a desktop demonstration for West Coast Wholesalers, Inc., with a Swing-oriented user interface and database-backed records. E0001 E0011

The source set also contains older Informix-4GL programs, including menu1.4gl.main, ordmenu.4gl.main, query1.4gl.main, d4_cust.4gl, d4_orders.4gl, and d4_report.4gl. These programs describe related business capabilities, but they must not be treated as interchangeable with the Java entry point com.ais.demo.D4_Main. In particular, ordmenu.4gl.main contains implemented Modify and Delete paths, while Java D4_Orders.update_order() and D4_Orders.delete_order() are explicitly reported as stubs. The Java target and the legacy 4GL programs therefore provide related evidence about the domain, not proof of identical current behavior. E0007 E0012

The capability hierarchy is consequently best understood as a set of business responsibilities with different implementation confidence: customer maintenance is substantially evidenced in the Java target; order entry and customer-based order viewing are implemented; stock maintenance and some reporting options remain placeholders; and the legacy 4GL sources document additional behavior that is not automatically established for the Java runtime. Detailed component boundaries and calls belong in C07, while the corresponding interfaces and database exchanges are covered in C08.

Customer and account maintenance

Customer maintenance is the most complete business capability in the Java evidence. D4_Cust supports adding one or multiple customers, query and browse, updating a selected customer, deleting a selected customer, help, and state selection. Customer records contain customer_num, fname, lname, company, address1, address2, city, state, zipcode, and phone. The customer browse is ordered by last name and provides Next, Previous, First, Last, Select, and Quit actions. E0007

Customer creation collects the customer number, name, company, address, city, state, ZIP code, and phone, then inserts the record and obtains the generated identifier. An interrupted entry does not write the intended change; the Java evidence reports interruption through F2 or Ctrl-Y, while the help and 4GL evidence also describe DEL, Ctrl-C, or related interrupt conventions. These key differences belong to the particular implementation or documentation variant and should not be collapsed into one universal key binding. E0007 E0003

Customer update applies changes to the selected customer and can restore the stored row when input is interrupted. Customer deletion requires a selected customer and confirmation. The deletion path checks whether related rows exist and refuses deletion when the customer has orders. However, one Java analysis reports a query counting all rows in orders while displaying the message that the customer has “active orders”; the evidence does not establish whether completed orders are intended to remain blocking. That business-rule question is unresolved and belongs with the validation detail in C05. E0002 E0007

The older d4_cust.4gl source provides a closely related capability: CONSTRUCT-based customer selection, customer help identifiers 1001–1010, state validation, and a state-list selection window. It confirms the domain responsibility, but not necessarily exact Java behavior. A local report that did not include D4_Cust.java establishes only that report’s coverage; other supplied evidence positively describes the Java implementation. E0007 E0012

Order capture and order inquiry

Order entry is the principal transactional capability. In the Java implementation, D4_Orders.add_order() first selects or creates a customer, gathers order header information, accepts line items, performs stock lookups, calculates each line total, inserts the order header and item rows, commits the transaction, and generates an invoice. The order-entry form includes order date, purchase-order number, shipping instructions, stock number, manufacturer code, description, quantity, unit price, and line total. Up to ten item records are represented in the shared item array. E0002 E0007

Stock lookup supports selecting a stock item while entering a stock number or manufacturer code. Once a valid stock record is found, the application supplies its description and unit price; line total is calculated as quantity multiplied by unit price. The Java and 4GL evidence both describe this relationship, although missing-row handling and the exact framework status semantics are not fully established. A failed lookup may clear description and price in one implementation, while the older 4GL analysis identifies a possible absence of explicit NOTFOUND handling. E0007 E0010

Order insertion has explicit rollback branches when the header insert or item insertion reports failure. The order number is obtained from SQLCA.SQLERRD[2] after insertion. The supplied Java evidence does not prove that every exception after transaction start invokes rollback, because the broad exception path delegates to _eh.handleException(_e) without visibly rolling back. The transaction and failure conditions are therefore implementation facts with a remaining framework dependency, as discussed in C04 and C08. E0012

Order inquiry retrieves orders for a selected customer, displays their items, and permits selection of an order. The Java get_order() path limits displayed items to ten and reports when more items exist. The older menu1.4gl.main additionally supports browsing customers and orders with first, last, next, previous, and select operations, with privileged users able to view an aggregated t_price. These are capabilities of a distinct 4GL program and should not be presented as unqualified behavior of com.ais.demo.D4_Main. E0007 E0009

Order totals have two related but not fully reconciled representations. Java order_total() applies a 1.1d multiplier to the line-item sum, while invoice generation separately calculates 6.5 percent sales tax and 3.5 percent shipping. The figures suggest an intended ten-percent relationship, but rounding behavior and whether the interactive and invoice totals are exactly equivalent depend on Money and invoice-framework implementations. E0002 E0012 The detailed monetary fields and representations belong in C06.

Stock and reference-data support

Stock is a dependency of order entry rather than a delivered maintenance capability in the Java application. D4_Main loads stock and state arrays before entering the main menu, and order entry can use stock records for descriptions, manufacturer codes, units, and prices. The shared arrays have capacities of 30 stock records and 50 state records; records beyond those limits are not retained by the loaders, with no evidenced user-facing overflow warning. E0012

The Java D4_Stock module exposes Add, Find, Update, and Delete menu entries, but each handler reports “This option has not been implemented.” The older 4GL d4_stock.4gl source has the same capability surface and the same explicit unimplemented result. Thus, stock data can support order capture and selection without implying stock CRUD. E0002 E0007

State data supports customer address entry. State records contain a two-character code and state name. The documented flow validates a state code and opens state_list when the code is missing or invalid, allowing the user to select a valid code. The Java form and the 4GL source both evidence a state-selection surface, but the exact callback wiring and validation behavior remain partly dependent on framework and omitted form artifacts. E0007 E0009

Reporting and invoice output

Reporting divides into implemented and placeholder capabilities. The Java D4_Report evidence supports mailing-label and accounts-receivable reports. Mailing labels use query-by-example customer selection, order results by ZIP code, and can target file, printer, or screen through print_option values f, p, and s. Accounts receivable selects orders whose paid_date is null and groups output by customer and order. E0002 E0007

Backlog and stock-list reports are exposed in the Reports menu and in the declared ID4_Report surface, but print_backlog() and print_stock() only report that the option has not been implemented. Help text independently marks these options as incomplete. Their presence in menus, interfaces, and report labels therefore establishes intended capability scope, not successful generation. E0002 E0004

Invoice generation is coupled to successful order creation. It combines order, customer, item, stock, and manufacturer information and selects output according to the print option. The precise lifecycle of report creation, row emission, and completion depends on external report classes that are not supplied. Report output and file/printer dependencies are detailed in C08 and operational prerequisites in C10. E0007 E0012

Demonstration, help, and command capabilities

The application includes a demonstration menu through D4_Demo, with commands for menus, windows, forms, scrolling, query construction, and reports. These commands display help identifiers rather than providing separate business processing. The source and help materials reference identifiers such as 1001–1010 and 2001–2008, but the complete help file is not consistently available across the supplied evidence. E0007

D4_Main.bang() accepts a command and passes it to _app.execute(true, Str.valueOf(cmd)). This is a technical command-execution capability rather than a business function and is security-sensitive because no allowlist is visible in the call site. The effective permissions and behavior of Application.execute() remain unresolved; security treatment belongs in C09. E0012

Overall, the current Java capability map supports customer maintenance, order creation and inquiry, reference-data use, two report types, invoice generation, and demonstration/help functions. Stock CRUD, order update/delete, backlog reporting, and stock-list reporting remain explicitly unimplemented in the Java evidence. Related 4GL programs show broader or different behavior, but their capabilities must remain attributed to those exact program names rather than projected onto the Java application.

Expandable topic detail

Browse all topic detail.

Capability hierarchy

Browse diagrams and evidence gaps.