Savor: Building on the sample

CN1_PROFILE=dev backend/server.sh run

mvn verify -Psimulator -DskipTests -Dcodename1.platform=javase

/// Places an order: prices it from the menu, holds the total on the card,
/// and writes it. A hold whose order could not be written is let go.
public OrderDto place(String customer, CartDto cart) throws IOException {
    String id = attemptOf(cart);
    CustomerOrder already = find(id);
    if (already != null) {
        return placedBefore(customer, already);
    }
    Quotes.Priced priced = quotes.quote(customer, cart);
    Restaurant restaurant = priced.restaurant;
    if (!Quotes.open(restaurant, quotes.minuteOfDay(System.currentTimeMillis()))) {
        throw new ResponseStatusException(409, restaurant.getName()
                + " is not taking orders right now");
    }
    if (priced.quote.subtotalCents() < restaurant.getMinimumCents()) {
        throw new ResponseStatusException(400, restaurant.getName()
                + " needs a bigger order");
    }
    if (cart.promoCode() != null && cart.promoCode().trim().length() > 0
            && priced.promo == null) {
        throw new ResponseStatusException(400, priced.quote.promoMessage());
    }
    // The same refusals store() makes under its locks, asked first without
    // them so an order that could never be accepted puts no hold on the
    // card and costs no call to the payment processor. store() still asks
    // again: two orders placed at once both pass here.
    eligible(customer);
    String[] method = payments.choose(customer, cart.paymentMethodId());
    String hold = payments.authorize(id, customer, method[0], priced.quote.totalCents(),
            priced.quote.currency());
    try {
        attempt(() -> store(id, customer, cart, priced, method, hold));
    } catch (IOException | RuntimeException failed) {
        CustomerOrder raced = find(id);
        if (raced != null && customer.equals(raced.getCustomer())) {
            // The same checkout sent twice at once: the other one wrote the
            // order. Its hold was asked for under the same key and may be
            // this very one, so it is not let go.
            return view(customer, false, id);
        }
        // Nothing was written, so the hold is let go by its reference.
        payments.releaseHold(id, hold);
        throw failed;
    }
    CustomerOrder order = find(id);
    tell(order);
    return view(customer, false, id);
}

/// The order's id: the checkout's own attempt id when the app sent one, so
/// a placement sent again after its answer was lost finds the order it
/// wrote instead of writing and charging another. Anything not shaped like
/// a server id gets a fresh one.
private static String attemptOf(CartDto cart) throws IOException {
    String attempt = cart.attemptId();
    if (attempt == null || attempt.length() != 32) {
        return Ids.next();
    }
    for (int iter = 0; iter < attempt.length(); iter++) {
        char c = attempt.charAt(iter);
        if (!(c >= '0' && c <= '9' || c >= 'a' && c <= 'f')) {
            return Ids.next();
        }
    }
    return attempt;
}

/// The answer to a checkout placed again: the order it already wrote. An
/// id another customer's order holds is refused without saying whose.
private OrderDto placedBefore(String customer, CustomerOrder order) throws IOException {
    if (!customer.equals(order.getCustomer())) {
        throw new ResponseStatusException(409, "Start the checkout again");
    }
    return view(customer, false, order.getId());
}

/// The refusals [#store] makes, without its locks. See [#place].
@Transactional(readOnly = true)
private Void eligible(String customer) {
    if (!enabled(customer)) {
        throw new ResponseStatusException(403, "This account is blocked");
    }
    if (orders.countByCustomerAndStateIn(customer, ACTIVE) >= MAX_ACTIVE) {
        throw new ResponseStatusException(409, "You already have " + MAX_ACTIVE
                + " orders on the way");
    }
    Profile profile = profiles.findById(customer);
    if (profile == null || !profile.isPhoneVerified()) {
        throw new ResponseStatusException(403, "Verify your phone number before you order");
    }
    return null;
}

@Transactional
private Void store(String id, String customer, CartDto cart, Quotes.Priced charged,
        String[] method, String hold) throws IOException {
    Quotes.Priced priced = charged;
    // Held first, so two orders placed at once count each other and not
    // just what had committed before either began.
    profiles.hold(customer);
    // The card was held with no transaction open, and that can take a
    // while: the account may have been blocked, or the restaurant paused
    // or suspended, since the checks before it. Asked again under the
    // locks those changes take, a refusal here lets the hold go.
    if (!enabled(customer)) {
        throw new ResponseStatusException(403, "This account is blocked");
    }
    Restaurant restaurant = restaurants.hold(priced.restaurant.getId()) == 0 ? null
            : restaurants.findById(priced.restaurant.getId());
    if (restaurant == null
            || !Quotes.open(restaurant, quotes.minuteOfDay(System.currentTimeMillis()))) {
        throw new ResponseStatusException(409, priced.restaurant.getName()
                + " is not taking orders right now");
    }
    if (orders.countByCustomerAndStateIn(customer, ACTIVE) >= MAX_ACTIVE) {
        throw new ResponseStatusException(409, "You already have " + MAX_ACTIVE
                + " orders on the way");
    }
    Profile profile = profiles.findById(customer);
    if (profile == null || !profile.isPhoneVerified()) {
        // The courier calls this number from the door.
        throw new ResponseStatusException(403, "Verify your phone number before you order");
    }
    // The menu was read before the card was held. Priced again under the
    // restaurant's lock, which every dish edit takes too (Restaurants.editing):
    // a dish now sold out or gone throws, a price that moved refuses, and either
    // way the hold is let go rather than charging for a menu that has changed.
    Quotes.Priced again = quotes.quote(customer, cart);
    if (again.quote.totalCents() != charged.quote.totalCents()) {
        throw new ResponseStatusException(409, "The menu changed while you were paying."
                + " Check your cart and try again");
    }
    // The minimum may have been raised while the card was held, and it
    // leaves the total alone, so the comparison above does not see it.
    if (again.quote.subtotalCents() < restaurant.getMinimumCents()) {
        throw new ResponseStatusException(400, restaurant.getName()
                + " needs a bigger order");
    }
    // The card may have been removed while it was held: Payments.remove
    // takes the profile lock held here and found no active order then.
    // Asked again, a card that is gone refuses with 400.
    payments.choose(customer, method[0]);
    priced = again;
    QuoteDto quote = priced.quote;
    long now = System.currentTimeMillis();
    CustomerOrder order = new CustomerOrder();
    order.setId(id);
    order.setCustomer(customer);
    order.setRestaurantId(priced.restaurant.getId());
    order.setRestaurantName(priced.restaurant.getName());
    order.setState(OrderState.PLACED);
    order.setSubtotalCents(quote.subtotalCents());
    order.setDeliveryFeeCents(quote.deliveryFeeCents());
    order.setServiceFeeCents(quote.serviceFeeCents());
    order.setSmallOrderCents(quote.smallOrderCents());
    order.setTaxCents(quote.taxCents());
    order.setDiscountCents(quote.discountCents());
    order.setTipCents(quote.tipCents());
    order.setTotalCents(quote.totalCents());
    order.setCommissionCents(priced.commissionCents);
    order.setCurrency(quote.currency());
    order.setPromoCode(priced.promo == null ? "" : priced.promo.getCode());
    order.setDropoffLat(cart.dropoffLat());
    order.setDropoffLng(cart.dropoffLng());
    order.setDropoffAddress(Text.required(cart.dropoffAddress(), 255, "the address"));
    order.setNote(Text.optional(cart.note(), 255, "the note"));
    order.setMethodId(method[0]);
    order.setMethodLabel(method[1]);
    order.setAuthorizationRef(hold);
    order.setPaymentStatus(Payments.CASH.equals(hold) ? Payments.PENDING : Payments.AUTHORIZED);
    order.setPrepMinutes(priced.restaurant.getPrepMinutes());
    order.setPlacedAt(now);
    order.setUpdatedAt(now);
    order.setReason("");
    orders.insert(order);
    for (int iter = 0; iter < priced.lines.size(); iter++) {
        OrderLineDto dto = priced.lines.get(iter);
        OrderLine line = new OrderLine();
        line.setId(Ids.next());
        line.setOrderId(id);
        line.setDishId(dto.dishId());
        line.setName(dto.name());
        line.setOptions(dto.options());
        line.setQuantity(dto.quantity());
        line.setUnitCents(dto.unitCents());
        line.setLineCents(dto.lineCents());
        line.setPosition(iter);
        lines.insert(line);
    }
    if (priced.promo != null) {
        // Keyed by code and account, so a second order racing this one
        // with the same code fails its insert and is rolled back.
        if (promoUses.existsById(Identifier.of(priced.promo.getCode(), customer))) {
            throw new ResponseStatusException(409, "You have already used that code");
        }
        PromoUse use = new PromoUse();
        use.setCode(priced.promo.getCode());
        use.setUsername(customer);
        use.setOrderId(id);
        promoUses.insert(use);
    }
    events.record(id, OrderState.PLACED, customer);
    return null;
}

/// The kitchen takes an order: it says how long it needs, and the order's
/// delivery starts looking for a courier in the same transaction.
public OrderDto accept(String actor, String restaurantId, String id, int prepMinutes)
        throws IOException {
    if (prepMinutes < 1 || prepMinutes > 180) {
        throw new ResponseStatusException(400, "Say how many minutes it needs");
    }
    attempt(() -> accepted(actor, restaurantId, id, prepMinutes));
    tell(find(id));
    // Once committed, as an offer is always made: a courier asked from
    // inside the transaction could be shown an order that then rolled back.
    deliveries.search(id);
    return view(actor, false, id);
}

@Transactional
private Void accepted(String actor, String restaurantId, String id, int prepMinutes)
        throws IOException {
    CustomerOrder order = kitchens(restaurantId, id);
    if (orders.accept(id, OrderStateMachine.sources(OrderState.ACCEPTED),
            OrderState.ACCEPTED, prepMinutes, System.currentTimeMillis()) != 1) {
        throw new ResponseStatusException(409, "That order is "
                + describe(order.getState()));
    }
    events.record(id, OrderState.ACCEPTED, actor);
    deliveries.dispatch(find(id), restaurants.findById(restaurantId));
    return null;
}

/// Creates the delivery for an order the kitchen has just accepted, with the
/// order's id, from the restaurant to the order's door. Runs inside the
/// transaction that accepts the order, so the two commit together; [#tick]
/// finds the delivery a courier from then on, while the kitchen cooks.
///
/// The courier is paid the delivery fee and the tip, so that is the fare a
/// courier is offered.
public void dispatch(CustomerOrder order, Restaurant restaurant) throws IOException {
    long now = System.currentTimeMillis();
    Delivery delivery = new Delivery();
    delivery.setId(order.getId());
    delivery.setState(DeliveryState.REQUESTED);
    delivery.setCustomer(order.getCustomer());
    delivery.setCourier("");
    delivery.setPickupLat(restaurant.getLat());
    delivery.setPickupLng(restaurant.getLng());
    delivery.setPickupAddress(address(restaurant.getName() + ", " + restaurant.getAddress()));
    delivery.setDropoffLat(order.getDropoffLat());
    delivery.setDropoffLng(order.getDropoffLng());
    delivery.setDropoffAddress(address(order.getDropoffAddress()));
    double meters = Quotes.roadMeters(restaurant.getLat(), restaurant.getLng(),
            order.getDropoffLat(), order.getDropoffLng());
    delivery.setDistanceMeters(meters);
    delivery.setDurationSeconds(meters / Quotes.METERS_PER_SECOND);
    delivery.setFareCents(order.getDeliveryFeeCents());
    delivery.setFeeCents(order.getDeliveryFeeCents());
    // A tip given at checkout is part of the order's total, taken with it,
    // so it is in the courier's share. The delivery's own tip is the one
    // given after it arrives, charged on its own: counting the checkout
    // tip there too would pay it to the courier twice.
    delivery.setTipCents(0L);
    delivery.setCourierCents(order.getDeliveryFeeCents() + order.getTipCents());
    delivery.setCurrency(order.getCurrency());
    delivery.setMethodId(order.getMethodId());
    delivery.setMethodLabel(order.getMethodLabel());
    delivery.setPaymentStatus(order.getPaymentStatus());
    delivery.setNote(order.getNote());
    delivery.setRequestedAt(now);
    delivery.setUpdatedAt(now);
    delivery.setSearchUntil(now + searchMillis);
    deliveries.insert(delivery);
    event(order.getId(), DeliveryState.REQUESTED, "");
}

private boolean tryMove(String id, DeliveryState to, String actor, String ownerField,
        String newCourier, Long newOfferExpiresAt) throws IOException {
    DeliveryState[] sources = DeliveryStateMachine.sources(to);
    if (sources.length == 0) {
        return false;
    }
    long now = System.currentTimeMillis();
    int moved;
    if (newOfferExpiresAt != null) {
        moved = deliveries.offer(id, sources, to, now, newCourier, newOfferExpiresAt.longValue());
    } else if (CUSTOMER.equals(ownerField)) {
        moved = deliveries.moveAsCustomer(id, sources, to, now, actor);
    } else if (!COURIER.equals(ownerField)) {
        moved = deliveries.moveByServer(id, sources, to, now);
    } else if (newCourier != null) {
        moved = deliveries.giveBack(id, sources, to, now, actor, newCourier);
    } else if (DeliveryState.ACCEPTED == to) {
        // An offer that has lapsed cannot be taken, even in the moment
        // before the sweep takes it back.
        moved = deliveries.takeOffer(id, sources, to, now, actor);
    } else {
        moved = deliveries.moveAsCourier(id, sources, to, now, actor);
    }
    if (moved != 1) {
        return false;
    }
    event(id, to, actor);
    return true;
}

/// Holds an order's total on the customer's card as the order is placed,
/// with no transaction open. Nothing is taken until the order arrives
/// ([#settle]); an order that never does lets the hold go ([#release]).
///
/// @return the hold's reference, or [#CASH] for an order paid in cash
/// - `ResponseStatusException` 402: when the card was refused
public String authorize(String orderId, String username, String methodId, long amountCents,
        String currency) throws IOException {
    if (CASH.equals(methodId)) {
        return CASH;
    }
    String[] references = chargeable(username, methodId);
    if (references == null) {
        throw new ResponseStatusException(402, "The card is no longer on the account");
    }
    try {
        return cut(provider.authorize("order-" + orderId, references[0], references[1],
                amountCents, currency, "Savor order"), 64);
    } catch (PaymentDeclinedException declined) {
        throw new ResponseStatusException(402, declined.getMessage());
    } catch (IOException unknown) {
        throw unavailable("card check", unknown);
    }
}

public interface PaymentProvider {
    /// `simulated` or `stripe`: what the app is told, so it knows how to add a
    /// card.
    String name();

    /// Opens the processor's record of a customer and returns its reference.
    String createCustomer(String username, String displayName) throws IOException;

    /// Deletes the processor's record of a customer, and the cards saved to it
    /// with it. A record that is already gone is deleted: this is asked again
    /// when the first answer was lost.
    void forgetCustomer(String customer) throws IOException;

    /// Begins saving a card to `customer`. `setupId` is the server's own id
    /// for the attempt, for the processor to hand back.
    Setup startCardSetup(String customer, String setupId) throws IOException;

    /// Finishes a setup and returns the card it saved.
    ///
    /// @param reference what [#startCardSetup] returned as the setup's reference
    /// @param typed the card as typed into the app, for a processor whose setup
    ///     is not hosted; ignored by one whose setup is
    /// - `PaymentDeclinedException`: when the card was refused or the setup was
    ///   not finished
    Card finishCardSetup(String customer, String reference, CardDto typed) throws IOException;

    /// Takes a saved card off `customer`, so that it can't be charged again.
    /// A card that is already off, or gone, is detached: this is asked again
    /// when the first answer was lost.
    ///
    /// @param token what [#finishCardSetup] returned as the card's token
    void detachCard(String customer, String token) throws IOException;

    /// Charges a saved card with its owner absent.
    ///
    /// @param key names this charge and no other. A processor asked twice with
    ///     the same key charges once, so a request repeated after a timeout
    ///     cannot take the money twice.
    /// @return the processor's reference for the charge
    /// - `PaymentDeclinedException`: when the card was refused
    /// - `IOException`: when the processor could not be asked
    String charge(String key, String customer, String token, long amountCents, String currency,
            String description) throws IOException;

    /// Returns `amountCents` of a charge to the card it came from.
    ///
    /// A processor may take the refund and only later say whether the bank
    /// returned the money: such a refund comes back [Refund#pending], and is
    /// asked about with [#refundStatus] until it has an answer.
    ///
    /// @return the refund as the processor took it
    /// - `IOException`: when the processor could not be asked, or refused the
    ///   refund outright
    Refund refund(String chargeReference, long amountCents) throws IOException;

    /// What became of a refund that was [Refund#pending]: [#REFUND_SUCCEEDED],
    /// [#REFUND_PENDING] while the processor still does not know, or
    /// [#REFUND_FAILED] when the money did not go back.
    String refundStatus(String refundReference) throws IOException;
    /// Holds `amountCents` on a saved card without taking it, for an order
    /// that is paid for only once it arrives. Keyed as [#charge] is.
    ///
    /// @return the processor's reference for the hold, for [#capture] or [#release]
    /// - `PaymentDeclinedException`: when the card was refused
    String authorize(String key, String customer, String token, long amountCents,
            String currency, String description) throws IOException;
    /// Takes `amountCents`, at most what was held, from a hold. A hold that was
    /// already captured is captured: this is asked again when the first answer
    /// was lost.
    void capture(String reference, long amountCents) throws IOException;
    /// Lets a hold go, so the money is the cardholder's again. A hold that is
    /// already let go is released.
    void release(String reference) throws IOException;

/// The approved restaurants that deliver to a point, filtered by cuisine and
/// by a word in the name, the cuisine or a dish, and sorted.
@Transactional(readOnly = true)
public List<RestaurantSummaryDto> nearby(String viewer, double lat, double lng,
        String cuisine, String text, String sort) throws IOException {
    if (!Geo.isPoint(lat, lng)) {
        throw new ResponseStatusException(400, "Choose where to deliver to");
    }
    double straight = Quotes.MAX_METERS / Quotes.ROAD_FACTOR;
    double dLat = straight / Geo.METERS_PER_DEGREE;
    double dLng = dLat / Math.max(0.01d, Math.cos(Math.toRadians(lat)));
    List<Restaurant> box = restaurants.inBox(APPROVED, lat - dLat, lat + dLat, lng - dLng,
            lng + dLng);
    String word = text == null ? "" : text.trim();
    Set<String> dishMatches = word.length() == 0 ? Collections.<String>emptySet()
            : dishMatches(box, word);
    Set<String> kept = favoriteIds(viewer);
    PricingDto pricing = quotes.pricing();
    int minute = quotes.minuteOfDay(System.currentTimeMillis());
    List<RestaurantSummaryDto> out = new ArrayList<RestaurantSummaryDto>();
    for (int iter = 0; iter < box.size(); iter++) {
        Restaurant restaurant = box.get(iter);
        if (cuisine != null && cuisine.length() > 0
                && !cuisine.equalsIgnoreCase(restaurant.getCuisine())) {
            continue;
        }
        if (word.length() > 0 && !contains(restaurant.getName(), word)
                && !contains(restaurant.getCuisine(), word)
                && !dishMatches.contains(restaurant.getId())) {
            continue;
        }
        double meters = Quotes.roadMeters(restaurant.getLat(), restaurant.getLng(), lat, lng);
        if (meters > Quotes.MAX_METERS) {
            continue;
        }
        out.add(summary(restaurant, meters, pricing, minute,
                kept.contains(restaurant.getId())));
    }
    sort(out, sort);
    return out;
}

/// Asks for a restaurant to be listed. It waits, unseen by customers, for
/// an admin to approve it; the applicant then joins its staff and gets the
/// merchant role. One application at a time per account.
@Transactional
public RestaurantDto apply(String username, RestaurantEditDto form) throws IOException {
    // Two submissions at once would both find no application below and
    // both insert one; holding the profile first makes the second wait
    // and then see the first.
    profiles.hold(username);
    Restaurant last = restaurants.findFirstByApplicantOrderByCreatedAtDesc(username);
    if (last != null && !Catalog.REJECTED.equals(last.getStatus())) {
        throw new ResponseStatusException(409, Catalog.PENDING.equals(last.getStatus())
                ? "Your application is waiting for review" : "You already have a restaurant");
    }
    Restaurant restaurant = new Restaurant();
    restaurant.setId(Ids.next());
    restaurant.setStatus(Catalog.PENDING);
    restaurant.setApplicant(username);
    restaurant.setReason("");
    restaurant.setPhotoId("");
    long now = System.currentTimeMillis();
    restaurant.setCreatedAt(now);
    restaurant.setUpdatedAt(now);
    fill(restaurant, form);
    restaurants.insert(restaurant);
    return catalog.detail(restaurant, username, 0d, 0d, true);
}

.authorizeHttpRequests(auth -> auth
        .requestMatchers(AntPathRequestMatcher.antMatcher("POST",
                "/api/account/register")).permitAll()
        .requestMatchers("/api/courier/**").hasRole(Roles.COURIER)
        .requestMatchers("/api/admin/**").hasRole(Roles.ADMIN)
        .requestMatchers("/api/merchant/**").hasRole(Roles.MERCHANT)
        .anyRequest().authenticated())

mvn -pl shared,backend -Dcodename1.platform=backend test
mvn -pl shared,backend -Dcodename1.platform=backend test -Dcn1.backend.compiledTests=true
./run-e2e.sh
./run-web-e2e.sh