Разработка мобильного приложения для аукциона

Разработка мобильного приложения для аукциона

Аукционное приложение — один из самых технически требовательных продуктов в мобильной разработке. Причина: состояние лота меняется в реальном времени, каждые несколько секунд может появиться новая ставка, и пользователь на другом конце ждёт мгновенного результата. Задержка в 2 секунды при отображении чужой ставки — и пользователь делает ставку на уже проигранную позицию.

Реальное время: WebSocket как основа

Polling для аукциона — неприемлемо. WebSocket с переподключением — стандарт:

// iOS: WebSocket через URLSessionWebSocketTask
class AuctionWebSocket {
    private var webSocketTask: URLSessionWebSocketTask?
    private var reconnectTimer: Timer?

    func connect(auctionId: String) {
        let url = URL(string: "wss://api.yourauction.com/auctions/\(auctionId)/live")!
        webSocketTask = URLSession.shared.webSocketTask(with: url)
        webSocketTask?.resume()
        receive()
    }

    private func receive() {
        webSocketTask?.receive { [weak self] result in
            switch result {
            case .success(let message):
                if case .string(let text) = message {
                    self?.handleMessage(text)
                }
                self?.receive() // продолжаем слушать
            case .failure:
                self?.scheduleReconnect()
            }
        }
    }

    private func scheduleReconnect() {
        reconnectTimer?.invalidate()
        reconnectTimer = Timer.scheduledTimer(withTimeInterval: 3.0, repeats: false) { [weak self] _ in
            self?.connect(auctionId: self?.currentAuctionId ?? "")
        }
    }
}

// Android: OkHttp WebSocket
class AuctionWebSocketManager(
    private val client: OkHttpClient,
    private val scope: CoroutineScope
) {
    private val _events = MutableSharedFlow<AuctionEvent>()
    val events: SharedFlow<AuctionEvent> = _events.asSharedFlow()

    fun connect(auctionId: String) {
        val request = Request.Builder()
            .url("wss://api.yourauction.com/auctions/$auctionId/live")
            .build()

        client.newWebSocket(request, object : WebSocketListener() {
            override fun onMessage(webSocket: WebSocket, text: String) {
                scope.launch {
                    val event = json.decodeFromString<AuctionEvent>(text)
                    _events.emit(event)
                }
            }

            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
                scope.launch {
                    delay(3000)
                    connect(auctionId)
                }
            }
        })
    }
}

Типы событий от сервера: BID_PLACED (новая ставка), AUCTION_EXTENDED (время продлено), AUCTION_ENDED, YOU_WON, YOU_WERE_OUTBID.

Гонка условий при ставках

Самая сложная бизнес-логика: два пользователя делают ставку одновременно. Пример:

1. Текущая ставка: 1000 ₽
2. Пользователь A видит 1000 ₽, делает ставку 1100 ₽
3. Пользователь B видит 1000 ₽, делает ставку 1050 ₽
4. Обе ставки приходят на сервер в один момент

Правильное решение — оптимистическая блокировка с версией лота:

def place_bid(user_id: str, lot_id: str, amount: Decimal, expected_version: int) -> BidResult:
    with db.transaction():
        lot = db.select_for_update(f"SELECT * FROM lots WHERE id = %s", lot_id)

        if lot.version != expected_version:
            # За это время кто-то уже поднял ставку
            return BidResult(
                success=False,
                reason="LOT_UPDATED",
                current_bid=lot.current_bid,
                new_version=lot.version
            )

        if amount <= lot.current_bid:
            return BidResult(
                success=False,
                reason="BID_TOO_LOW",
                current_bid=lot.current_bid,
                new_version=lot.version
            )

        db.execute(
            "UPDATE lots SET current_bid=%s, current_bidder=%s, version=version+1 WHERE id=%s",
            (amount, user_id, lot_id)
        )
        db.execute(
            "INSERT INTO bids (lot_id, user_id, amount) VALUES (%s, %s, %s)",
            (lot_id, user_id, amount)
        )

        broadcast_to_websockets(lot_id, {
            "type": "BID_PLACED",
            "amount": str(amount),
            "bidder": mask_username(user_id),
            "version": lot.version + 1
        })

        return BidResult(success=True, new_version=lot.version + 1)

При LOT_UPDATED клиент получает актуальную ставку и может предложить пользователю сделать новую с учётом текущей цены.

Автоставка (proxy bidding)

Пользователь устанавливает максимальную сумму, которую готов заплатить. Система автоматически повышает его ставку в ответ на ставки конкурентов — до установленного максимума.

def process_autobid(lot_id: str, new_bid_amount: Decimal, new_bidder_id: str):
    """Проверяем автоставки после каждой новой ставки"""
    autobids = db.get_active_autobids(lot_id, exclude_user=new_bidder_id)

    for autobid in sorted(autobids, key=lambda x: x.max_amount, reverse=True):
        counter_amount = new_bid_amount + lot.bid_step

        if counter_amount <= autobid.max_amount:
            # Автоматически ставим от имени держателя автоставки
            place_bid(autobid.user_id, lot_id, counter_amount, lot.version)
            break

Автоставка — источник конфликтов с пользователями, поэтому важна детальная история: «Ваша ставка 1 200 ₽ была автоматически повышена в ответ на ставку 1 100 ₽».

Продление времени anti-sniping

Снайпинг — ставка в последние секунды. Чтобы его избежать, аукцион продлевается при ставке в конце:

ANTI_SNIPING_THRESHOLD = timedelta(minutes=2)
ANTI_SNIPING_EXTENSION = timedelta(minutes=2)

def after_bid_placed(lot_id: str):
    lot = db.get_lot(lot_id)
    time_remaining = lot.ends_at - datetime.utcnow()

    if time_remaining < ANTI_SNIPING_THRESHOLD:
        new_end_time = lot.ends_at + ANTI_SNIPING_EXTENSION
        db.update_lot_end_time(lot_id, new_end_time)
        broadcast_to_websockets(lot_id, {
            "type": "AUCTION_EXTENDED",
            "new_end_time": new_end_time.isoformat()
        })

Таймер на клиенте синхронизируется с серверным временем при получении AUCTION_EXTENDED.

Платёжная логика

Победитель получает push-уведомление и имеет ограниченное время (24–48 часов) для оплаты. Если не оплатил — лот переходит следующему по ставке или выставляется повторно.

Для ценных лотов — предоплата перед участием: депозит блокируется при регистрации на торги, возвращается проигравшим.

Комиссия с продажи (покупателя или продавца) удерживается при оплате. Payouts продавцу — через Stripe Connect или аналог.

Ориентиры по срокам

Стоимость рассчитывается индивидуально после анализа требований.