# Com / Optage / Kopt / Bp

## Overview

The `com.optage.kopt.bp` package is a subpackage within the `com.optage.kopt.batch` module. It contains classes related to **SOD (Send-Out-Data) processing** — specifically the preparation, validation, formatting, and dispatch of SOD data. The package also includes a base service class for shared initialization logic and a test fixture for the SOD dispatch component.

All classes in this package are currently auto-generated fixture classes used for `SPEC-SCOPED-WIKI` testing. The implementations are lightweight stubs, but the structure reflects the intended architecture: a coordinated pipeline where SOD data is prepared, validated, optionally formatted, and then dispatched via a send channel.

## Key Classes and Interfaces

### [JKKBpServiceBase](src/main/java/com/optage/kopt/bp/JKKBpServiceBase.java)

A base service class that provides shared initialization logic for SOD-related batch processing. It exposes a single protected method:

- **`baseInit()`** — Performs common startup or setup operations shared across child services. Being `protected`, this is intended to be overridden or invoked by subclasses. The current implementation is a no-op placeholder, but the method exists to be extended.

### [JKKHakkoSODCC](src/main/java/com/optage/kopt/bp/JKKHakkoSODCC.java)

The central controller class for SOD dispatch operations. It orchestrates the end-to-end SOD sending workflow:

- **`dispatch()`** — Initiates the SOD send process by creating and invoking a `JKKSodSendCC` instance's `send()` method. This is the primary entry point for triggering SOD dispatch.
- **`validate()`** — Performs input or state validation by delegating to `KKPRC14901.check()`. This class (`KKPRC14901`) is **external to this package** and lives in a different module. Validation appears to run before dispatch to ensure data integrity.

### [JKKHakkoSODHelper](src/main/java/com/optage/kopt/bp/JKKHakkoSODHelper.java)

A utility class providing helper methods for SOD data manipulation. It has one public method:

- **`format(String input)`** — Returns the trimmed version of the input string (`input.trim()`). This is used to normalize SOD data before processing or sending.

### [JKKSodSendCC](src/main/java/com/optage/kopt/bp/JKKSodSendCC.java)

Handles the actual sending of SOD data. Its `send()` method encapsulates the SOD dispatch logic — the mechanism of transmission (e.g., file output, API call, or message queue) is not yet implemented in the fixture, but the class is designed as the dedicated outbound channel for SOD payloads.

### [JKKHakkoSODCCTest](src/test/java/com/optage/kopt/bp/JKKHakkoSODCCTest.java)

A JUnit 4 test class for `JKKHakkoSODCC`. It contains one test method:

- **`testMain()`** — A placeholder test using `assertTrue(true)` that verifies the test framework integration. This class is marked with `is_test: true` by the build tooling due to its location under `src/test/` and its use of JUnit annotations.

## How It Works

The SOD dispatch flow is orchestrated by `JKKHakkoSODCC`:

1. **Validation** — `validate()` is called first, delegating to the external `KKPRC14901` class to check data validity.
2. **Formatting** — Data can be normalized via `JKKHakkoSODHelper.format()`, which trims whitespace.
3. **Dispatch** — `dispatch()` creates a `JKKSodSendCC` instance and calls `send()` to transmit the SOD data.
4. **Base setup** — `JKKBpServiceBase.baseInit()` provides a hook for shared initialization that subclasses can invoke during setup.

### Architecture Diagram

```
flowchart TD
    BPO["BPO Package"] --> JHS["JKKHakkoSODHelper"]
    BPO --> JHSOC["JKKHakkoSODCC"]
    BPO --> JSOC["JKKSodSendCC"]
    BPO --> JBS["JKKBpServiceBase"]
    BPO --> JTC["JKKHakkoSODCCTest"]
    JHSOC --> JSOC
    JHSOC --> KKPRC14901["KKPRC14901 (external)"]
```

The diagram shows the internal structure and key dependency: `JKKHakkoSODCC` depends on both `JKKSodSendCC` (internal) and `KKPRC14901` (external to this package).

## Data Model

No entity or DTO classes are defined within this package. The package operates on data passed as parameters (e.g., `String` input to `format()`) or managed by external classes.

## Dependencies and Integration

- **Parent module**: The package belongs to `com.optage.kopt.batch`, a parent batch-processing module.
- **External dependency**: `KKPRC14901` is referenced by `JKKHakkoSODCC.validate()` but is not defined in this package. It resides in a separate module and must be available on the classpath.
- **Internal coupling**: `JKKHakkoSODCC` directly instantiates `JKKSodSendCC` in its `dispatch()` method, creating a tight coupling between these two classes.

## Notes for Developers

- **Fixture status**: All classes are currently auto-generated fixture stubs for `SPEC-SCOPED-WIKI` tests. The methods contain no-op or minimal implementations. As you extend this package, replace the stubs with full business logic.
- **Hard-coded instantiation**: `JKKHakkoSODCC.dispatch()` uses `new JKKSodSendCC()` directly rather than dependency injection. Consider refactoring to use an interface and injected dependency if you need to mock the send behavior in tests.
- **External class coupling**: The `KKPRC14901` class is called from `validate()` without any import visible in the fixture. Verify the correct import path and ensure the class is available at runtime.
- **Test coverage**: The current test (`testMain`) is a placeholder that asserts `true`. Replace it with meaningful assertions against `JKKHakkoSODCC` behavior once the implementation is fleshed out.
- **Package naming**: The `bp` suffix likely stands for a business process area (possibly "batch process"). Keep this convention consistent when adding new classes.