role_requests.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::RoleRequests {
 
namespace Status {
  constexpr name PENDING  = "pending"_n;
  constexpr name APPROVED = "approved"_n;
  constexpr name DECLINED = "declined"_n;
}
 
namespace Direction {
  constexpr name REQUEST = "request"_n;
  constexpr name INVITE  = "invite"_n;
}
 
namespace RequestType {
  constexpr name ROLE        = "role"_n;
  constexpr name RATE_UPDATE = "rateupdate"_n;
}
 
namespace Role {
  constexpr name CREATOR = "creator"_n;
  constexpr name AUTHOR  = "author"_n;
  constexpr name MASTER  = "master"_n;
  constexpr name NONE    = name{};   
}
 
struct [[eosio::table, eosio::contract(CAPITAL)]] role_request {
  uint64_t      id;                                                  
  eosio::name   coopname;                                            
  checksum256   request_hash;                                        
  checksum256   project_hash;                                        
  eosio::name   username;                                            
  eosio::name   master;                                              
  eosio::name   role             = Role::NONE;                       
  eosio::asset  rate_per_hour    = asset(0, _root_govern_symbol);    
  uint64_t      hours_per_day    = 0;                                
  eosio::asset  approved_rate    = asset(0, _root_govern_symbol);    
  uint64_t      approved_hours   = 0;                                
  eosio::name   direction        = Direction::REQUEST;               
  eosio::name   request_type     = RequestType::ROLE;                
  eosio::name   status           = Status::PENDING;                  
  std::string   description;                                         
  std::string   decline_reason;                                      
  time_point_sec created_at      = current_time_point();
 
  uint64_t   primary_key() const   { return id; }
  checksum256 by_request_hash() const { return request_hash; }
  uint128_t  by_project_user() const {
    return combine_checksum_ids(project_hash, username);
  }
};
 
typedef eosio::multi_index<
  "rolerequests"_n, role_request,
  indexed_by<"byhash"_n,     const_mem_fun<role_request, checksum256, &role_request::by_request_hash>>,
  indexed_by<"byprojuser"_n, const_mem_fun<role_request, uint128_t,   &role_request::by_project_user>>
> role_requests_index;
 
inline std::optional<role_request> get_role_request(eosio::name coopname, const checksum256 &request_hash) {
  role_requests_index t(_capital, coopname.value);
  auto idx = t.get_index<"byhash"_n>();
  auto itr = idx.find(request_hash);
  if (itr == idx.end()) return std::nullopt;
  return role_request(*itr);
}
 
inline role_request get_role_request_or_fail(eosio::name coopname, const checksum256 &request_hash) {
  auto v = get_role_request(coopname, request_hash);
  eosio::check(v.has_value(), "Заявка на роль не найдена");
  return v.value();
}
 
inline void create(
  eosio::name coopname,
  const checksum256 &request_hash,
  const checksum256 &project_hash,
  eosio::name username,
  eosio::name master,
  eosio::name role,
  const eosio::asset &rate_per_hour,
  uint64_t hours_per_day,
  eosio::name direction,
  eosio::name request_type,
  const std::string &description
) {
  role_requests_index t(_capital, coopname.value);
  eosio::check(!get_role_request(coopname, request_hash).has_value(),
               "Заявка с указанным хэшем уже существует");
 
  uint64_t id = get_global_id_in_scope(_capital, coopname, "rolerequests"_n);
  t.emplace(RamPayer::of(t, coopname), [&](auto &r) {
    r.id = id;
    r.coopname = coopname;
    r.request_hash = request_hash;
    r.project_hash = project_hash;
    r.username = username;
    r.master = master;
    r.role = role;
    r.rate_per_hour = rate_per_hour;
    r.hours_per_day = hours_per_day;
    r.direction = direction;
    r.request_type = request_type;
    r.status = Status::PENDING;
    r.description = description;
    r.created_at = current_time_point();
  });
}
 
inline void validate_role_or_fail(eosio::name role) {
  eosio::check(
    role == Role::CREATOR || role == Role::AUTHOR || role == Role::MASTER,
    "Допустимые роли заявки: creator, author, master"
  );
}
 
inline void apply_role_to_project(
  eosio::name coopname,
  const checksum256 &project_hash,
  eosio::name username,
  eosio::name role
) {
  if (role == Role::AUTHOR) {
    eosio::action(
      eosio::permission_level{coopname, "active"_n},
      _capital,
      "addauthor"_n,
      std::make_tuple(coopname, project_hash, username)
    ).send();
  } else if (role == Role::MASTER) {
    eosio::action(
      eosio::permission_level{coopname, "active"_n},
      _capital,
      "setmaster"_n,
      std::make_tuple(coopname, project_hash, username)
    ).send();
  }
}
 
inline void approve(
  eosio::name coopname,
  uint64_t request_id,
  const eosio::asset &approved_rate,
  uint64_t approved_hours
) {
  role_requests_index t(_capital, coopname.value);
  auto itr = t.find(request_id);
  eosio::check(itr != t.end(), "Заявка не найдена");
  eosio::check(itr->status == Status::PENDING, "Заявка уже обработана");
  t.modify(itr, RamPayer::of(t, coopname), [&](auto &r) {
    r.status = Status::APPROVED;
    r.approved_rate = approved_rate;
    r.approved_hours = approved_hours;
  });
}
 
inline void decline(eosio::name coopname, uint64_t request_id, const std::string &reason) {
  role_requests_index t(_capital, coopname.value);
  auto itr = t.find(request_id);
  eosio::check(itr != t.end(), "Заявка не найдена");
  eosio::check(itr->status == Status::PENDING, "Заявка уже обработана");
  t.modify(itr, RamPayer::of(t, coopname), [&](auto &r) {
    r.status = Status::DECLINED;
    r.decline_reason = reason;
  });
}
 
} // namespace Capital::RoleRequests
 
// Плательщик за оперативную память строк таблицы — правило в lib/core/ram_payer.hpp.
RAM_PAYER_CLASS(Capital::RoleRequests::role_request, cooperative);