# Getting Started

Welcome to the team! This guide answers "I just joined — where do I start reading?"

## What This Project Does

This is a Java business information system that handles orders, products, and label data processing. The codebase manages core domain entities for order creation workflows, product identification, and structured record processing — many with Japanese-language comments, indicating the system serves a Japan-focused business domain.

## Recommended Reading Order

Follow this order to build your understanding efficiently:

1. **[OrderProcessor](src/main/java/OrderProcessor.java)** — the primary entry point with the most complete Javadoc documentation
2. **[ProductService](src/main/java/ProductService.java)** — a small, self-contained class that clarifies how product data is structured
3. **[LargeFieldMap](src/main/java/LargeFieldMap.java)** — a central data carrier used by several other classes; understanding its fields unlocks the rest of the system
4. **Label model classes** — review the entity family to understand data structures (see below)
5. **[MultiPattern](src/main/java/MultiPattern.java)** — contains ticket-style markers (`ANK-4494-00-00`) that may point to related change history
6. **[A](src/main/java/A.java)** — a trivial placeholder; read in seconds for completeness

## Key Entry Points

| Class | Purpose | Why Start Here |
|---|---|---|
| [OrderProcessor](src/main/java/OrderProcessor.java) | Order creation workflow | Most documented class; primary business entry point |
| [ProductService](src/main/java/ProductService.java) | Product identifier holder | Minimal class; establishes domain vocabulary |
| [LargeFieldMap](src/main/java/LargeFieldMap.java) | General-purpose data carrier | Referenced by OrderProcessor, LargeBusinessLabelClass, and PartialLabelEntity |

The dependency flow is:

```mermaid
flowchart LR
    O["OrderProcessor"] --> LFM["LargeFieldMap"]
    P["ProductService"] --> O["OrderProcessor"]
    LBC["LargeBusinessLabelClass"] --> LFM["LargeFieldMap"]
    PLC["PartialLabelEntity"] --> LFM["LargeFieldMap"]
    MLC["MixedLabelClass"] --> MP["MultiPattern"]
```

**Read order rationale:**

- `ProductService` depends on `OrderProcessor`, so read `OrderProcessor` first (or together)
- `OrderProcessor`, `LargeBusinessLabelClass`, and `PartialLabelEntity` all depend on `LargeFieldMap`, so understanding `LargeFieldMap` will clarify their fields
- `MixedLabelClass` depends on `MultiPattern`, which contains the shared pattern fields (processing categories, movement categories)

## Project Structure

```
src/main/java/
  OrderProcessor.java          # Business logic — order creation
  ProductService.java          # Business logic — product lookup
  LargeFieldMap.java           # Central data carrier
  LargeBusinessLabelClass.java # 50-field business label entity
  MixedLabelClass.java         # Partially labeled label class
  PartialLabelEntity.java      # Entity with labeled/unlabeled field mix
  MultiPattern.java            # Shared pattern/flag fields
  EucJpClass.java              # User/org context entity
  A.java                       # Empty marker class
```

All classes live in the **default package** (no `package` declaration). There are no sub-packages, no tests, no resources, and no configuration files visible in the source tree.

### Class Categories

| Category | Classes | Role |
|---|---|---|
| **Business logic** | `OrderProcessor`, `ProductService` | Handle domain operations |
| **Data carriers** | `LargeFieldMap`, `MultiPattern` | Hold structured field data between components |
| **Label entities** | `LargeBusinessLabelClass`, `MixedLabelClass`, `PartialLabelEntity`, `EucJpClass` | Represent business records with typed fields |
| **Placeholders** | `A` | Marker/placeholder class |

## Configuration

No configuration files (such as `pom.xml`, `build.gradle`, or `application.yml`) were found in the repository. The project uses the standard Java layout under `src/main/java`, suggesting it is built with a standard Java build tool (Maven or Gradle) that has not been committed to this repository snapshot.

Key files to check in your local build setup:

- **`pom.xml`** or **`build.gradle`** — if present at the repository root, these define dependencies and build configuration
- **`src/main/resources/`** — typically holds runtime configuration (not present in this snapshot)

## Common Patterns

### 1. Label/Record Classes Use `fieldXX` Conventions

Classes like `LargeBusinessLabelClass` and `LargeFieldMap` use numbered field names (`field01`, `field02`, etc.) for their bulk properties. Each field is annotated with a Japanese-language comment describing its business purpose. This pattern suggests the classes were generated or hand-crafted to map to an external schema (e.g., EDI, flat file, or database columns).

### 2. Processing Flags Use `Div` Suffix

Enums or flag fields often end in `Div` (short for "division"):

- `syoriDiv` — processing category
- `idoDiv` — movement category
- `statusDiv` — status indicator

These appear across multiple entity classes, suggesting a shared convention for categorizing records.

### 3. Japanese Comments Document Field Purpose

Many classes contain Javadoc or inline comments in Japanese (e.g., 日本語ラベル — "Japanese label"). These comments describe what each field represents in the business domain. When reading entity classes, pay close attention to these comments — they are the primary source of field-level documentation.

### 4. Ticket Markers in Code

`MultiPattern.java` contains ticket-style block comments (e.g., `ANK-4494-00-00`). These markers indicate the class was added or modified as part of a specific change request. They may help you trace change history or find related work.

### 5. Shared Data Carrier Pattern

`LargeFieldMap` is the most-referenced class in the dependency graph (referenced by `OrderProcessor`, `LargeBusinessLabelClass`, and `PartialLabelEntity`). It carries identifiers and flags between components:

- `templateID` — template identifier
- `identifyCD` — identification code
- `key_svc_kei_no` — key service/contract number
- `syoriDiv` — processing division
- `idoDiv` — movement division

When debugging or extending the system, start by understanding what data flows through `LargeFieldMap`.

## Quick Checklist for Your First Day

- [ ] Read `src/main/java/OrderProcessor.java` — understand the `createOrder` method
- [ ] Read `src/main/java/LargeFieldMap.java` — understand the field naming conventions
- [ ] Skim `src/main/java/LargeBusinessLabelClass.java` — notice the 50-field pattern and Japanese comments
- [ ] Understand the dependency chain: `ProductService` -> `OrderProcessor` -> `LargeFieldMap`
- [ ] Check for `pom.xml` or `build.gradle` to verify how to build the project locally
- [ ] Verify you can compile the source with a Java compiler (no external frameworks required)

## Where to Go Next

After the basics, explore:

- **[Repository Overview](../overview.md)** — architecture diagram, technology stack, and detailed module descriptions
- Any ticket or issue tracking references in the code comments for deeper context on individual classes