create unique index uq_one_active_approved_quote_version
    on quote_version (tenant_id, quote_id)
    where status in ('APPROVED');

create table quote (
    quote_id uuid primary key,
    tenant_id uuid not null,
    quote_number text not null,
    customer_id uuid not null,
    opportunity_ref text,
    created_by uuid not null,
    created_at timestamptz not null default now(),
    unique (tenant_id, quote_number)
);

create table quote_version (
    quote_version_id uuid primary key,
    tenant_id uuid not null,
    quote_id uuid not null references quote(quote_id),
    version_number int not null,
    status text not null,
    configuration_snapshot_id uuid,
    pricing_snapshot_id uuid,
    currency char(3),
    list_total numeric(19, 4),
    discount_total numeric(19, 4),
    net_total numeric(19, 4),
    valid_from timestamptz,
    valid_until timestamptz,
    approval_required boolean not null default false,
    approval_status text,
    document_id uuid,
    accepted_at timestamptz,
    accepted_by text,
    cancelled_at timestamptz,
    expired_at timestamptz,
    previous_version_id uuid,
    superseded_by_version_id uuid,
    row_version bigint not null default 0,
    created_at timestamptz not null default now(),
    updated_at timestamptz not null default now(),
    unique (tenant_id, quote_id, version_number),
    check (status in ('DRAFT', 'PRICED', 'SUBMITTED', 'APPROVAL_PENDING', 'REJECTED', 'APPROVED', 'ACCEPTED', 'EXPIRED', 'CANCELLED')),
    check (approval_status is null or approval_status in ('NOT_REQUIRED', 'PENDING', 'APPROVED', 'REJECTED'))
);

create index idx_quote_version_status
    on quote_version (tenant_id, status, updated_at desc);

create table quote_line (
    quote_line_id uuid primary key,
    tenant_id uuid not null,
    quote_version_id uuid not null references quote_version(quote_version_id),
    line_number int not null,
    parent_line_id uuid,
    item_ref_type text not null,
    item_ref_id text not null,
    display_name text not null,
    quantity numeric(19, 4) not null,
    charge_type text not null,
    charge_period text,
    unit_amount numeric(19, 4) not null,
    list_amount numeric(19, 4) not null,
    discount_amount numeric(19, 4) not null,
    net_amount numeric(19, 4) not null,
    snapshot jsonb not null,
    unique (quote_version_id, line_number)
);

create table quote_audit_event (
    quote_audit_event_id uuid primary key,
    tenant_id uuid not null,
    quote_version_id uuid not null,
    event_type text not null,
    actor_id uuid,
    actor_type text not null,
    reason text,
    before_state text,
    after_state text,
    evidence jsonb not null default '{}'::jsonb,
    created_at timestamptz not null default now()
);

public record SubmitQuoteCommand(
    UUID tenantId,
    UUID quoteVersionId,
    UUID actorId,
    long expectedRowVersion,
    String idempotencyKey
) {}

public final class QuoteVersion {
    private final UUID quoteVersionId;
    private final UUID tenantId;
    private QuoteStatus status;
    private UUID configurationSnapshotId;
    private UUID pricingSnapshotId;
    private MoneyTotals totals;
    private boolean approvalRequired;
    private ApprovalStatus approvalStatus;
    private Instant validUntil;
    private long rowVersion;

    public void attachPricing(PricingSnapshot snapshot) {
        requireStatus(QuoteStatus.DRAFT, QuoteStatus.PRICED);
        requireConfigurationMatches(snapshot.configurationSnapshotId());
        this.pricingSnapshotId = snapshot.pricingSnapshotId();
        this.totals = snapshot.totals();
        this.status = QuoteStatus.PRICED;
    }

    public SubmitOutcome submit(List<ApprovalSignal> signals, Instant now) {
        requireStatus(QuoteStatus.PRICED);
        requirePricingSnapshot();
        requireConfigurationSnapshot();

        this.approvalRequired = !signals.isEmpty();
        if (approvalRequired) {
            this.status = QuoteStatus.APPROVAL_PENDING;
            this.approvalStatus = ApprovalStatus.PENDING;
            return SubmitOutcome.approvalRequired(signals);
        }

        this.status = QuoteStatus.APPROVED;
        this.approvalStatus = ApprovalStatus.NOT_REQUIRED;
        this.validUntil = now.plus(Duration.ofDays(30));
        return SubmitOutcome.approvedWithoutApproval();
    }

    public void accept(Instant now, String acceptedBy) {
        requireStatus(QuoteStatus.APPROVED);
        if (validUntil != null && now.isAfter(validUntil)) {
            throw new DomainException("QUOTE_EXPIRED");
        }
        this.status = QuoteStatus.ACCEPTED;
    }
}

quote.setStatus(request.status());
quoteMapper.update(quote);

quote.accept(clock.instant(), command.acceptedBy());
quoteRepository.save(quote, command.expectedRowVersion());

paths:
  /quotes:
    post:
      operationId: createQuoteDraft
      parameters:
        - name: Idempotency-Key
          in: header
          required: true
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateQuoteDraftRequest'
      responses:
        '201':
          description: Quote draft created

  /quote-versions/{quoteVersionId}/pricing:
    put:
      operationId: attachPricingSnapshot
      parameters:
        - name: If-Match
          in: header
          required: true
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [pricingSnapshotId]
              properties:
                pricingSnapshotId:
                  type: string
                  format: uuid
      responses:
        '200':
          description: Pricing attached
        '409':
          description: Invalid quote state or stale row version
        '422':
          description: Pricing snapshot does not match quote configuration

  /quote-versions/{quoteVersionId}/submit:
    post:
      operationId: submitQuote
      parameters:
        - name: Idempotency-Key
          in: header
          required: true
          schema:
            type: string
        - name: If-Match
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Quote submitted

  /quote-versions/{quoteVersionId}/accept:
    post:
      operationId: acceptQuote
      parameters:
        - name: Idempotency-Key
          in: header
          required: true
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/AcceptQuoteRequest'
      responses:
        '200':
          description: Quote accepted
        '409':
          description: Quote cannot be accepted in current state
        '410':
          description: Quote expired

@Path("/quote-versions")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class QuoteVersionResource {

    private final QuoteApplicationService quoteApplicationService;

    @POST
    @Path("/{quoteVersionId}/submit")
    public Response submit(
        @PathParam("quoteVersionId") UUID quoteVersionId,
        @HeaderParam("Idempotency-Key") String idempotencyKey,
        @HeaderParam("If-Match") String ifMatch
    ) {
        SubmitQuoteCommand command = new SubmitQuoteCommand(
            RequestContext.tenantId(),
            quoteVersionId,
            RequestContext.actorId(),
            RowVersionHeader.parse(ifMatch),
            idempotencyKey
        );
        QuoteVersionDto result = quoteApplicationService.submit(command);
        return Response.ok(result).build();
    }
}

<select id="findQuoteVersionForUpdate" resultMap="QuoteVersionRowMap">
    select *
    from quote_version
    where tenant_id = #{tenantId}
      and quote_version_id = #{quoteVersionId}
</select>

<update id="updateQuoteVersion">
    update quote_version
    set status = #{status},
        configuration_snapshot_id = #{configurationSnapshotId},
        pricing_snapshot_id = #{pricingSnapshotId},
        currency = #{currency},
        list_total = #{listTotal},
        discount_total = #{discountTotal},
        net_total = #{netTotal},
        valid_until = #{validUntil},
        approval_required = #{approvalRequired},
        approval_status = #{approvalStatus},
        accepted_at = #{acceptedAt},
        accepted_by = #{acceptedBy},
        row_version = row_version + 1,
        updated_at = now()
    where tenant_id = #{tenantId}
      and quote_version_id = #{quoteVersionId}
      and row_version = #{expectedRowVersion}
</update>

{
  "quoteVersionId": "qv-001",
  "customerId": "cust-001",
  "netTotal": "10800000.00",
  "currency": "IDR",
  "signals": [
    {
      "code": "DISCOUNT_ABOVE_THRESHOLD",
      "severity": "APPROVAL_REQUIRED",
      "evidence": {
        "effectiveDiscountPercent": "25.00",
        "thresholdPercent": "20.00"
      }
    }
  ]
}

create table quote_document (
    document_id uuid primary key,
    tenant_id uuid not null,
    quote_version_id uuid not null references quote_version(quote_version_id),
    document_type text not null,
    storage_uri text not null,
    content_hash text not null,
    generated_at timestamptz not null default now(),
    generated_by uuid,
    check (document_type in ('CUSTOMER_QUOTE_PDF', 'INTERNAL_REVIEW_PDF'))
);

{
  "eventId": "evt-quote-accepted-001",
  "eventType": "QuoteAccepted",
  "eventVersion": 1,
  "tenantId": "tenant-001",
  "occurredAt": "2026-07-02T11:00:00Z",
  "aggregateType": "QuoteVersion",
  "aggregateId": "qv-001",
  "payload": {
    "quoteId": "quote-001",
    "quoteVersionId": "qv-001",
    "quoteNumber": "Q-2026-00001",
    "customerId": "cust-001",
    "configurationSnapshotId": "cfgsnap-001",
    "pricingSnapshotId": "pricesnap-001",
    "currency": "IDR",
    "netTotal": "10800000.00",
    "acceptedAt": "2026-07-02T11:00:00Z",
    "acceptedBy": "customer@example.com"
  }
}

quote-summary:{tenantId}:{quoteVersionId}

create table quote_acceptance_idempotency (
    tenant_id uuid not null,
    quote_version_id uuid not null,
    idempotency_key text not null,
    request_hash text not null,
    status text not null,
    accepted_at timestamptz,
    created_order_ref text,
    created_at timestamptz not null default now(),
    primary key (tenant_id, quote_version_id, idempotency_key),
    check (status in ('IN_PROGRESS', 'ACCEPTED', 'FAILED'))
);

select quote_version_id
from quote_version
where tenant_id = #{tenantId}
  and status = 'APPROVED'
  and valid_until < now()
order by valid_until
limit #{batchSize};

where status = 'APPROVED'
  and valid_until >= now()

where status = 'APPROVED'
  and valid_until < now()

DRAFT -> PRICED -> SUBMITTED -> APPROVED -> ACCEPTED