marketplace.hpp

См. документацию.

#pragma once
 
#include <functional>
#include <optional>
#include <string>
 
#include <eosio/crypto.hpp>
#include <eosio/eosio.hpp>
 
#include "../../consts.hpp"
#include "../../domain/document_core.hpp"
#include "../../domain/table_ledger2_userwallets.hpp"
#include "../../domain/table_marketplace_fee_config.hpp"
#include "../ledger2/ledger2.hpp"
#include "../branch/branch.hpp"
#include "memo.hpp"
#include "../../domain/table_marketplace_orders.hpp"
#include "../../domain/table_marketplace_return_requests.hpp"
#include "../../domain/table_marketplace_writeoff_proposals.hpp"
 
namespace Marketplace {
 
using namespace eosio;
 
// ── Количество как fixed-point asset (Эпик 17, L14) ─────────────────────
//
// quantity/actual_quantity — asset с символом единицы измерения (KG/LTR/PCS);
// дробность веса/объёма выражается младшими единицами (0.500 KG = 500 г).
// Штука (PCS, precision 0) неделима на уровне типа. Цена задаётся за одну
// базовую единицу (кг/литр/штуку) money-asset'ом _root_govern_symbol.
 
inline bool is_valid_unit_symbol(const eosio::symbol& sym) {
  return sym == _unit_kg || sym == _unit_liter || sym == _unit_piece;
}
 
inline void check_quantity(const eosio::asset& quantity) {
  eosio::check(quantity.is_valid() && is_valid_unit_symbol(quantity.symbol),
               "Недопустимая единица измерения количества");
  eosio::check(quantity.amount > 0, "Количество должно быть больше нуля");
}
 
inline void check_packaging(const eosio::asset& quantity, const eosio::asset& package_size) {
  if (package_size.amount == 0) return;  // отпуск по мере
  eosio::check(package_size.is_valid() && package_size.symbol == quantity.symbol,
               "Единица упаковки не совпадает с единицей количества");
  eosio::check(package_size.amount > 0, "Размер упаковки должен быть больше нуля");
  eosio::check(quantity.amount % package_size.amount == 0,
               "Количество должно быть кратно размеру упаковки");
}
 
inline eosio::asset calc_cost(const eosio::asset& quantity, const eosio::asset& unit_price,
                              const eosio::asset& package_size = eosio::asset(0, _unit_piece)) {
  if (package_size.amount > 0) {
    const int64_t packages = quantity.amount / package_size.amount;  // точно (кратность — check_packaging)
    const uint128_t total = static_cast<uint128_t>(packages) *
                            static_cast<uint128_t>(unit_price.amount);
    return eosio::asset(static_cast<int64_t>(total), unit_price.symbol);
  }
  int64_t scale = 1;
  for (uint8_t i = 0; i < quantity.symbol.precision(); ++i) scale *= 10;
  const uint128_t num = static_cast<uint128_t>(quantity.amount) *
                        static_cast<uint128_t>(unit_price.amount);
  const int64_t amount = static_cast<int64_t>((num + static_cast<uint128_t>(scale) / 2) / scale);
  return eosio::asset(amount, unit_price.symbol);
}
 
inline eosio::asset pro_rata(const eosio::asset& total, int64_t part, int64_t whole) {
  eosio::check(whole > 0, "Некорректная база для расчёта пропорциональной доли");
  const uint128_t num = static_cast<uint128_t>(total.amount) * static_cast<uint128_t>(part);
  const int64_t amount =
      static_cast<int64_t>((num + static_cast<uint128_t>(whole) / 2) / static_cast<uint128_t>(whole));
  return eosio::asset(amount, total.symbol);
}
 
// ── Orders ──────────────────────────────────────────────────────────────
 
inline std::optional<order> get_order_by_hash(eosio::name coopname, const checksum256& order_hash) {
  orders_index orders(_marketplace, coopname.value);
  auto idx = orders.get_index<"byhash"_n>();
  auto it = idx.find(order_hash);
  if (it == idx.end()) return std::nullopt;
  return *it;
}
 
inline order get_order_by_hash_or_fail(eosio::name coopname, const checksum256& order_hash,
                                       const std::string& msg = "Заказ не найден по хэшу") {
  auto o = get_order_by_hash(coopname, order_hash);
  eosio::check(o.has_value(), msg);
  return *o;
}
 
inline void update_order(eosio::name coopname, uint64_t order_id, const std::function<void(order&)>& fn) {
  orders_index orders(_marketplace, coopname.value);
  auto it = orders.find(order_id);
  eosio::check(it != orders.end(), "Заказ не найден по id");
  orders.modify(it, RamPayer::of(orders, coopname), [&](auto& o) { fn(o); });
}
 
inline std::optional<eosio::asset> get_asset_extension(const eosio::binary_extension<eosio::asset>& ext) {
  if (!ext.has_value() || ext.value().symbol.raw() == 0) return std::nullopt;
  return ext.value();
}
 
inline eosio::asset get_accepted_cost(const order& o) {
  return get_asset_extension(o.accepted_cost).value_or(o.fact_cost);
}
 
inline eosio::asset get_payout_withheld(const order& o) {
  return get_asset_extension(o.payout_withheld).value_or(eosio::asset(0, _root_govern_symbol));
}
 
inline bool is_supplier_settlement_open(const order& o) {
  return o.payout_status != OrderPayoutStatus::COMPLETED;
}
 
// Терминал жизненного цикла: запись стирается из RAM, история процесса
// остаётся в журнале действий (blockchain_actions парсера).
inline void erase_order(eosio::name coopname, uint64_t order_id) {
  orders_index orders(_marketplace, coopname.value);
  auto it = orders.find(order_id);
  eosio::check(it != orders.end(), "Заказ не найден по id");
  orders.erase(it);
}
 
// ── Return requests ─────────────────────────────────────────────────────
 
inline uint64_t next_return_request_id(eosio::name coopname) {
  return_requests_index requests(_marketplace, coopname.value);
  const uint64_t id = requests.available_primary_key();
  return id == 0 ? 1 : id;
}
 
inline bool has_open_return_request(eosio::name coopname, const order& o) {
  if (o.return_request_id == 0) return false;
  return_requests_index requests(_marketplace, coopname.value);
  auto it = requests.find(o.return_request_id);
  return it != requests.end() && it->original_order_hash == o.hash;
}
 
inline std::optional<return_request> get_return_request_by_hash(eosio::name coopname,
                                                                 const checksum256& request_hash) {
  return_requests_index requests(_marketplace, coopname.value);
  auto idx = requests.get_index<"byhash"_n>();
  auto it = idx.find(request_hash);
  if (it == idx.end()) return std::nullopt;
  return *it;
}
 
inline return_request get_return_request_by_hash_or_fail(eosio::name coopname,
                                                          const checksum256& request_hash,
                                                          const std::string& msg = "Заявление на возврат не найдено по хэшу") {
  auto r = get_return_request_by_hash(coopname, request_hash);
  eosio::check(r.has_value(), msg);
  return *r;
}
 
inline void update_return_request(eosio::name coopname, uint64_t request_id,
                                  const std::function<void(return_request&)>& fn) {
  return_requests_index requests(_marketplace, coopname.value);
  auto it = requests.find(request_id);
  eosio::check(it != requests.end(), "Заявление на возврат не найдено по id");
  requests.modify(it, RamPayer::of(requests, coopname), [&](auto& r) { fn(r); });
}
 
// Терминал жизненного цикла: запись стирается из RAM (история — в журнале
// действий). order.return_request_id НЕ сбрасывается — повторный возврат по
// тому же заказу не открывается.
inline void erase_return_request(eosio::name coopname, uint64_t request_id) {
  return_requests_index requests(_marketplace, coopname.value);
  auto it = requests.find(request_id);
  eosio::check(it != requests.end(), "Заявление на возврат не найдено по id");
  requests.erase(it);
}
 
inline void check_return_request_branch(eosio::name coopname, const return_request& r,
                                        eosio::name braname) {
  auto o = get_order_by_hash_or_fail(coopname, r.original_order_hash);
  eosio::check(o.delivery_braname == braname,
               "Заявление на возврат рассматривает кооперативный участок выдачи заказа");
}
 
// ── Writeoff proposals ──────────────────────────────────────────────────
 
inline std::optional<writeoff_proposal> get_writeoff_proposal_by_hash(eosio::name coopname,
                                                                       const checksum256& proposal_hash) {
  writeoff_proposals_index proposals(_marketplace, coopname.value);
  auto idx = proposals.get_index<"byhash"_n>();
  auto it = idx.find(proposal_hash);
  if (it == idx.end()) return std::nullopt;
  return *it;
}
 
inline writeoff_proposal get_writeoff_proposal_by_hash_or_fail(eosio::name coopname,
                                                                const checksum256& proposal_hash,
                                                                const std::string& msg = "Проект списания не найден по хэшу") {
  auto p = get_writeoff_proposal_by_hash(coopname, proposal_hash);
  eosio::check(p.has_value(), msg);
  return *p;
}
 
inline void update_writeoff_proposal(eosio::name coopname, uint64_t proposal_id,
                                     const std::function<void(writeoff_proposal&)>& fn) {
  writeoff_proposals_index proposals(_marketplace, coopname.value);
  auto it = proposals.find(proposal_id);
  eosio::check(it != proposals.end(), "Проект списания не найден по id");
  proposals.modify(it, RamPayer::of(proposals, coopname), [&](auto& p) { fn(p); });
}
 
// Терминал жизненного цикла: запись стирается из RAM, история процесса —
// в журнале действий (blockchain_actions парсера).
inline void erase_writeoff_proposal(eosio::name coopname, uint64_t proposal_id) {
  writeoff_proposals_index proposals(_marketplace, coopname.value);
  auto it = proposals.find(proposal_id);
  eosio::check(it != proposals.end(), "Проект списания не найден по id");
  proposals.erase(it);
}
 
// ── Warranty claims (претензии поставщику, p.mkt.claim) ─────────────────
 
inline std::optional<warranty_claim> get_claim_by_hash(eosio::name coopname,
                                                       const checksum256& claim_hash) {
  warranty_claims_index claims(_marketplace, coopname.value);
  auto idx = claims.get_index<"byhash"_n>();
  auto it = idx.find(claim_hash);
  if (it == idx.end()) return std::nullopt;
  return *it;
}
 
inline warranty_claim get_claim_by_hash_or_fail(eosio::name coopname,
                                                const checksum256& claim_hash,
                                                const std::string& msg = "Гарантийная претензия поставщику не найдена по хэшу") {
  auto c = get_claim_by_hash(coopname, claim_hash);
  eosio::check(c.has_value(), msg);
  return *c;
}
 
inline void update_claim(eosio::name coopname, uint64_t claim_id,
                         const std::function<void(warranty_claim&)>& fn) {
  warranty_claims_index claims(_marketplace, coopname.value);
  auto it = claims.find(claim_id);
  eosio::check(it != claims.end(), "Гарантийная претензия не найдена по id");
  claims.modify(it, RamPayer::of(claims, coopname), [&](auto& c) { fn(c); });
}
 
// ── Cross-contract read: ledger2 wallet/userwallet balances ─────────────
//
// Используется в createorder для guard'а Locked Decision L6 (без отрицательного
// баланса) — проверка достаточности средств заказчика на паевом кошельке
// перед вызовом o.mkt.lock.
//
// ВАЖНО: контракт marketplace не вызывает ledger2::walletop напрямую, а только
// читает state (RAM-таблицы wallets2 / userwallets через cross-contract scope).
// Все мутации идут через `Ledger2::apply` (см. lib/core/ledger2/ledger2.hpp).
 
struct UserWalletAvailable {
  eosio::asset available = eosio::asset(0, _root_govern_symbol);
  eosio::asset blocked   = eosio::asset(0, _root_govern_symbol);
  bool exists = false;
};
 
inline UserWalletAvailable get_user_wallet_balance(eosio::name coopname,
                                                    eosio::name wallet_id,
                                                    eosio::name username) {
  // userwallets_index — глобальный typedef в lib/domain/table_ledger2_userwallets.hpp.
  // Для cross-contract read берём scope = coopname.value, code = _ledger2.
  userwallets_index user_wallets(_ledger2, coopname.value);
  auto idx = user_wallets.get_index<"byuserwallet"_n>();
  auto it = idx.find(combine_ids(wallet_id.value, username.value));
  if (it == idx.end()) {
    return UserWalletAvailable{};
  }
  return UserWalletAvailable{ it->available, it->blocked, true };
}
 
// ── Членский взнос «Стола заказов» (requirement b6 «Экономика КУ») ──────
 
constexpr uint64_t DEFAULT_MEMBERSHIP_FEE_PERCENT = 300000;
 
inline uint64_t get_membership_fee_percent(eosio::name coopname) {
  mkt_config_singleton cfg(_marketplace, coopname.value);
  return cfg.exists() ? cfg.get().membership_fee_percent : DEFAULT_MEMBERSHIP_FEE_PERCENT;
}
 
inline eosio::asset calc_membership_fee(const eosio::asset& base, uint64_t fee_percent) {
  const int64_t amount = static_cast<int64_t>(
      static_cast<uint128_t>(base.amount) * fee_percent / HUNDR_PERCENTS);
  return eosio::asset(amount, _root_govern_symbol);
}
 
inline eosio::asset get_order_membership_fee(const order& o) {
  return o.membership_fee;
}
 
inline void require_member_fee(eosio::name coopname, eosio::name orderer,
                               const eosio::asset& membership_fee) {
  if (membership_fee.amount <= 0) return;
  auto member = get_user_wallet_balance(coopname, ledger2_wallets::MARKETPLACE_MEMBER_FUND, orderer);
  eosio::check(member.available >= membership_fee,
               std::string{"Недостаточно членских средств Стола заказов на членский взнос участка: требуется "} +
                 membership_fee.to_string() + ", доступно " + member.available.to_string() +
                 ". Сначала подайте заявление о переводе паевого взноса в программу.");
}
 
inline void lock_order_body(eosio::name coopname, uint64_t order_id, eosio::name orderer,
                            const checksum256& order_hash, const eosio::asset& body,
                            const std::string& program_memo, const std::string& wallet_memo) {
  if (body.amount <= 0) return;
  auto program = get_user_wallet_balance(coopname, ledger2_wallets::MARKETPLACE_SHARE_FUND, orderer);
  const eosio::asset from_program = program.available >= body ? body : program.available;
  const eosio::asset from_wallet  = body - from_program;
  if (from_wallet.amount > 0) {
    auto wallet = get_user_wallet_balance(coopname, ledger2_wallets::SHARE_FUND_PAY, orderer);
    eosio::check(wallet.available >= from_wallet,
                 std::string{"Недостаточно паевых средств для заказа: требуется с Цифрового кошелька "} +
                   from_wallet.to_string() + ", доступно " + wallet.available.to_string() +
                   " (свободный паевой Стола заказов " + program.available.to_string() + " уже учтён)");
  }
  if (from_program.amount > 0) {
    Ledger2::apply(_marketplace, coopname,
                   operations::marketplace::LOCK_FROM_SHARE,
                   processes::marketplace::SUPPLY,
                   from_program, orderer, order_hash, program_memo);
  }
  if (from_wallet.amount > 0) {
    Ledger2::apply(_marketplace, coopname,
                   operations::marketplace::LOCK_ORDER,
                   processes::marketplace::SUPPLY,
                   from_wallet, orderer, order_hash, wallet_memo);
  }
}
 
inline void lock_membership_fee(eosio::name coopname, uint64_t order_id,
                                eosio::name orderer, const checksum256& order_hash,
                                const eosio::asset& fee, const std::string& memo) {
  if (fee.amount <= 0) return;
  Ledger2::apply(_marketplace, coopname,
                 operations::marketplace::MEMBERSHIP_FEE_LOCK,
                 processes::marketplace::SUPPLY,
                 fee, orderer, order_hash, memo);
}
 
inline void refund_membership_fee_if_any(eosio::name coopname, const order& o) {
  const eosio::asset fee = get_order_membership_fee(o);
  if (fee.amount <= 0) return;
  Ledger2::apply(_marketplace, coopname,
                 operations::marketplace::MEMBERSHIP_FEE_REFUND,
                 processes::marketplace::SUPPLY,
                 fee, o.orderer, o.hash,
                 Marketplace::Memo::get_membership_fee_refund_memo(o.id));
}
 
inline void refund_order_full(eosio::name coopname, const order& o) {
  Ledger2::apply(_marketplace, coopname,
                 operations::marketplace::UNLOCK_ORDER,
                 processes::marketplace::SUPPLY,
                 o.total_cost, o.orderer, o.hash,
                 Marketplace::Memo::get_cancel_order_memo(o.id));
  refund_membership_fee_if_any(coopname, o);
}
 
inline constexpr uint64_t REFUSAL_PENALTY_PERCENT = 50;
 
inline void clear_issue_documents(order& o) {
  o.issue_statement.emplace(document2{});
  o.issue_protocol.emplace(document2{});
  o.issue_act1      = document2{};
  o.issue_act2      = document2{};
  o.actual_quantity = o.quantity;
  o.fact_cost       = o.total_cost;
}
 
inline eosio::asset refusal_penalty_share(const eosio::asset& base) {
  return calc_membership_fee(base, REFUSAL_PENALTY_PERCENT);
}
 
inline void retain_refusal_penalty(eosio::name coopname, const order& o) {
  // ── Тело заказа 50/50 ──
  const eosio::asset penalty_body = refusal_penalty_share(o.total_cost);
  const eosio::asset refund_body  = o.total_cost - penalty_body;
 
  if (refund_body.amount > 0) {
    Ledger2::apply(_marketplace, coopname,
                   operations::marketplace::UNLOCK_ORDER,
                   processes::marketplace::SUPPLY,
                   refund_body, o.orderer, o.hash,
                   Marketplace::Memo::get_cancel_order_memo(o.id));
  }
  if (penalty_body.amount > 0) {
    // Транзит: удержанная половина тела → пул членских взносов, откуда уйдёт в КУ.
    Ledger2::apply(_marketplace, coopname,
                   operations::marketplace::REFUSAL_PENALTY,
                   processes::marketplace::SUPPLY,
                   penalty_body, o.orderer, o.hash,
                   Marketplace::Memo::get_refusal_penalty_transit_memo(o.id));
  }
 
  // ── Членский взнос 50/50 ──
  const eosio::asset fee         = get_order_membership_fee(o);
  const eosio::asset penalty_fee = refusal_penalty_share(fee);
  const eosio::asset refund_fee  = fee - penalty_fee;
  if (refund_fee.amount > 0) {
    Ledger2::apply(_marketplace, coopname,
                   operations::marketplace::MEMBERSHIP_FEE_REFUND,
                   processes::marketplace::SUPPLY,
                   refund_fee, o.orderer, o.hash,
                   Marketplace::Memo::get_membership_fee_refund_memo(o.id));
  }
 
  // ── Удержанное (тело + взнос) — в общий кошелёк КУ выдачи ──
  // Обе удержанные половины сейчас в пуле членских взносов: тело — транзитом
  // выше, взнос — ещё с createorder; единым accrue зачисляются в w.brn.common.
  const eosio::asset to_common = penalty_body + penalty_fee;
  if (to_common.amount > 0) {
    Branch::accrue(_marketplace, coopname, o.delivery_braname,
                   to_common, processes::marketplace::SUPPLY, o.hash,
                   Marketplace::Memo::get_refusal_penalty_distribute_memo(o.id));
  }
}
 
// ── Факты Стола заказов для других контрактов (shared-слой, задача 99D-16) ──
// Код других контрактов таблиц marketplace напрямую не читает: участок,
// выход пайщика и прочие проверки спрашивают Стол заказов только этими методами.
 
inline bool has_orders_at_branch(eosio::name coopname, eosio::name braname) {
  orders_index orders(_marketplace, coopname.value);
  auto by_delivery = orders.get_index<"bydelivbra"_n>();
  if (by_delivery.find(braname.value) != by_delivery.end()) return true;
  auto by_accept = orders.get_index<"byacceptbra"_n>();
  return by_accept.find(braname.value) != by_accept.end();
}
 
inline void check_member_can_exit(eosio::name coopname, eosio::name username) {
  const eosio::asset reserve =
      get_user_wallet_balance(coopname, ledger2_wallets::MARKETPLACE_ORDER_LOCK, username).available;
  eosio::check(reserve.amount == 0,
               "Выход из кооператива невозможен: под заказы Стола заказов зарезервировано " +
                 reserve.to_string() + " — завершите или отмените заказы");
 
  return_requests_index requests(_marketplace, coopname.value);
  auto by_orderer = requests.get_index<"byorderer"_n>();
  eosio::check(by_orderer.find(username.value) == by_orderer.end(),
               "Выход из кооператива невозможен: открыто заявление на гарантийный возврат в Столе заказов — дождитесь его рассмотрения");
}
 
inline void settle_member_fund_on_exit(eosio::name actor, eosio::name coopname,
                                       eosio::name username, const checksum256& exit_hash) {
  const eosio::asset balance =
      get_user_wallet_balance(coopname, ledger2_wallets::MARKETPLACE_MEMBER_FUND, username).available;
  if (balance.amount <= 0) return;
 
  Ledger2::apply(actor, coopname, operations::marketplace::EXIT_FEE_TO_POOL,
                 processes::wallet::WITHDRAW, balance, username, exit_hash,
                 "Остаток членского кошелька Стола заказов в пул взносов при выходе, username=" +
                   username.to_string());
 
  const auto braname = ::get_participant_branch(coopname, username);
  if (!braname.has_value() || !Branch::exists(coopname, *braname)) return;
  Branch::accrue(actor, coopname, *braname, balance, processes::wallet::WITHDRAW, exit_hash,
                 "Остаток членского кошелька Стола заказов в общий кошелёк участка при выходе, username=" +
                   username.to_string());
}
 
} // namespace Marketplace