expenses.hpp

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

#pragma once
 
 
#include "../../../lib/core/ram_payer.hpp"
#include <eosio/eosio.hpp>
#include <eosio/asset.hpp>
 
using namespace eosio;
using std::string;
 
namespace Capital::Expenses {
   namespace Status {
    const eosio::name CREATED = "created"_n;        
    const eosio::name APPROVED = "approved"_n;      
    const eosio::name AUTHORIZED = "authorized"_n;  
    const eosio::name PAID = "paid"_n;             
    const eosio::name DECLINED = "declined"_n;      
  }
}
 
namespace Capital {
 
  struct [[eosio::table, eosio::contract(CAPITAL)]] expense {
    uint64_t id;                                    
    name coopname;                                  
    name username;                                  
    
    name status = Expenses::Status::CREATED;        
    checksum256 project_hash;                       
    checksum256 expense_hash;                       
    uint64_t fund_id;                               
    eosio::asset amount;                            
    std::string description;                        
 
    document2 expense_statement;                    
    document2 approved_statement;                   
    document2 authorization;                        
                                  
    time_point_sec spended_at = current_time_point(); 
 
    uint64_t primary_key() const { return id; }     
    uint64_t by_username() const { return username.value; } 
    checksum256 by_expense_hash() const { return expense_hash; } 
    checksum256 by_project_hash() const { return project_hash; } 
  };
 
  typedef eosio::multi_index<
    "expenses"_n, expense,
    indexed_by<"byusername"_n, const_mem_fun<expense, uint64_t, &expense::by_username>>,
    indexed_by<"byhash"_n, const_mem_fun<expense, checksum256, &expense::by_expense_hash>>,
    indexed_by<"byprojhash"_n, const_mem_fun<expense, checksum256, &expense::by_project_hash>>
  > expense_index;
 
 
 inline std::optional<expense> get_expense(eosio::name coopname, const checksum256 &hash) {
  expense_index expenses(_capital, coopname.value);
  auto expense_index = expenses.get_index<"byhash"_n>();
 
  auto itr = expense_index.find(hash);
  if (itr == expense_index.end()) {
      return std::nullopt;
  }
 
  return expense(*itr);
}
 
} // namespace Capital
 
namespace Capital::Expenses {
 
 
  inline expense get_expense_or_fail(eosio::name coopname, const checksum256 &expense_hash) {
    auto expense = Capital::get_expense(coopname, expense_hash);
    eosio::check(expense.has_value(), "Расход с указанным хэшем не найден");
    return expense.value();
  }
 
  inline void create_expense(eosio::name coopname, const checksum256 &project_hash, 
                            const checksum256 &expense_hash, eosio::name username, 
                            const eosio::asset &amount,
                            const std::string &description, const document2 &statement) {
    
    Capital::expense_index expenses(_capital, coopname.value);
    uint64_t expense_id = get_global_id_in_scope(_capital, coopname, "expenses"_n);
    
    expenses.emplace(RamPayer::of(expenses, coopname), [&](auto &e) {
      e.id = expense_id;
      e.coopname = coopname;
      e.username = username;
      e.project_hash = project_hash;
      e.expense_hash = expense_hash;
      e.fund_id = Ledger::accounts::ECONOMIC_ACTIVITY_FUND;
      e.status = Expenses::Status::CREATED;
      e.spended_at = current_time_point();
      e.expense_statement = statement;
      e.amount = amount;
      e.description = description;
    });
  }
 
  inline void set_approved(eosio::name coopname, uint64_t expense_id, 
                          const document2 &approved_statement) {
    Capital::expense_index expenses(_capital, coopname.value);
    auto expense = expenses.find(expense_id);
    
    eosio::check(expense != expenses.end(), "Расход не найден");
    
    expenses.modify(expense, RamPayer::of(expenses, coopname), [&](auto &e) {
      e.status = Expenses::Status::APPROVED;
      e.approved_statement = approved_statement;
    });
  }
 
  inline void set_authorized(eosio::name coopname, uint64_t expense_id, 
                            const document2 &authorization) {
    Capital::expense_index expenses(_capital, coopname.value);
    auto expense = expenses.find(expense_id);
    eosio::check(expense != expenses.end(), "Расход не найден");
    
    expenses.modify(expense, RamPayer::of(expenses, coopname), [&](auto &e) {
      e.status = Expenses::Status::AUTHORIZED;
      e.authorization = authorization;
    });
  }
 
  inline void delete_expense(eosio::name coopname, uint64_t expense_id) {
    Capital::expense_index expenses(_capital, coopname.value);
    auto expense = expenses.find(expense_id);
    eosio::check(expense != expenses.end(), "Расход не найден");
 
    expenses.erase(expense);
  }
 
} // namespace Capital::Expenses
 
namespace Capital {
 
  struct [[eosio::table, eosio::contract(CAPITAL)]] program_expense {
    uint64_t id;                                    
    name coopname;                                  
    name username;                                  
 
    name status = Expenses::Status::CREATED;        
    checksum256 expense_hash;                       
    uint64_t fund_id;                               
    eosio::asset amount;                            
    std::string description;                        
 
    document2 expense_statement;                    
    document2 approved_statement;                   
    document2 authorization;                        
 
    time_point_sec spended_at = current_time_point();
 
    uint64_t primary_key() const { return id; }
    uint64_t by_username() const { return username.value; }
    checksum256 by_expense_hash() const { return expense_hash; }
  };
 
  typedef eosio::multi_index<
    "progexpenses"_n, program_expense,
    indexed_by<"byusername"_n, const_mem_fun<program_expense, uint64_t, &program_expense::by_username>>,
    indexed_by<"byhash"_n, const_mem_fun<program_expense, checksum256, &program_expense::by_expense_hash>>
  > program_expense_index;
 
  inline std::optional<program_expense> get_program_expense(eosio::name coopname, const checksum256 &hash) {
    program_expense_index t(_capital, coopname.value);
    auto idx = t.get_index<"byhash"_n>();
    auto itr = idx.find(hash);
    if (itr == idx.end()) return std::nullopt;
    return program_expense(*itr);
  }
 
} // namespace Capital
 
namespace Capital::Expenses {
 
  inline program_expense get_program_expense_or_fail(eosio::name coopname, const checksum256 &expense_hash) {
    auto v = Capital::get_program_expense(coopname, expense_hash);
    eosio::check(v.has_value(), "Программный расход с указанным хэшем не найден");
    return v.value();
  }
 
  inline void create_program_expense(
    eosio::name coopname,
    const checksum256 &expense_hash,
    eosio::name username,
    const eosio::asset &amount,
    const std::string &description,
    const document2 &statement
  ) {
    Capital::program_expense_index t(_capital, coopname.value);
    uint64_t id = get_global_id_in_scope(_capital, coopname, "progexpenses"_n);
 
    t.emplace(RamPayer::of(t, coopname), [&](auto &e) {
      e.id = id;
      e.coopname = coopname;
      e.username = username;
      e.expense_hash = expense_hash;
      e.fund_id = Ledger::accounts::GENERAL_EXPENSES;
      e.status = Status::CREATED;
      e.spended_at = current_time_point();
      e.expense_statement = statement;
      e.amount = amount;
      e.description = description;
    });
  }
 
  inline void delete_program_expense(eosio::name coopname, uint64_t id) {
    Capital::program_expense_index t(_capital, coopname.value);
    auto itr = t.find(id);
    eosio::check(itr != t.end(), "Программный расход не найден");
    t.erase(itr);
  }
 
} // namespace Capital::Expenses
 
// Плательщик за оперативную память строк таблицы — правило в lib/core/ram_payer.hpp.
RAM_PAYER_CLASS(Capital::expense, cooperative);
RAM_PAYER_CLASS(Capital::program_expense, cooperative);