contributors.hpp

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

#pragma once
 
 
#include "../../../lib/core/ram_payer.hpp"
#include "../core/gamification/gamification.hpp"
 
using namespace eosio;
using std::string;
 
namespace Capital {
 
  struct [[eosio::table, eosio::contract(CAPITAL)]] contributor {
    uint64_t id;                                    
    name coopname;                                  
    name username;                                  
    checksum256 contributor_hash;                   
    time_point_sec created_at;                      
    name status;                                    
    std::string memo;                                
    bool is_external_contract = false;              
    document2 contract;                             
    std::vector<checksum256> appendixes;            
    
    eosio::asset rate_per_hour = asset(0, _root_govern_symbol); 
    uint64_t hours_per_day = 0; 
    eosio::asset debt_amount = asset(0, _root_govern_symbol);   
    
    eosio::asset contributed_as_investor = asset(0, _root_govern_symbol);     
    eosio::asset contributed_as_creator = asset(0, _root_govern_symbol);      
    eosio::asset contributed_as_author = asset(0, _root_govern_symbol);       
    eosio::asset contributed_as_coordinator = asset(0, _root_govern_symbol);  
    eosio::asset contributed_as_contributor = asset(0, _root_govern_symbol);  
    eosio::asset contributed_as_propertor = asset(0, _root_govern_symbol);    
    
    // Геймификация: уровень и энергия
    uint32_t level = 1;                                   
    double energy = 99.9999999999;                                 
    time_point_sec last_energy_update;                    
    
    uint64_t primary_key() const { return id; }                  
    uint64_t by_username() const { return username.value; }      
    checksum256 by_hash() const { return contributor_hash; }     
    uint64_t by_investor_rating() const { return contributed_as_investor.amount; }     
    uint64_t by_creator_rating() const { return contributed_as_creator.amount; }       
    uint64_t by_author_rating() const { return contributed_as_author.amount; }         
    uint64_t by_coordinator_rating() const { return contributed_as_coordinator.amount; } 
    uint64_t by_contributor_rating() const { return contributed_as_contributor.amount; } 
    uint64_t by_propertor_rating() const { return contributed_as_propertor.amount; }     
    uint64_t by_rating() const { return contributed_as_investor.amount + contributed_as_creator.amount + contributed_as_author.amount + contributed_as_coordinator.amount + contributed_as_contributor.amount + contributed_as_propertor.amount; } 
  };
 
typedef eosio::multi_index<
    "contributors"_n, contributor,
    indexed_by<"byusername"_n, const_mem_fun<contributor, uint64_t, &contributor::by_username>>,
    indexed_by<"byhash"_n, const_mem_fun<contributor, checksum256, &contributor::by_hash>>,
    indexed_by<"byinvrate"_n, const_mem_fun<contributor, uint64_t, &contributor::by_investor_rating>>,
    indexed_by<"bycreatorate"_n, const_mem_fun<contributor, uint64_t, &contributor::by_creator_rating>>,
    indexed_by<"byauthorate"_n, const_mem_fun<contributor, uint64_t, &contributor::by_author_rating>>,
    indexed_by<"bycoordrate"_n, const_mem_fun<contributor, uint64_t, &contributor::by_coordinator_rating>>,
    indexed_by<"bycontrate"_n, const_mem_fun<contributor, uint64_t, &contributor::by_contributor_rating>>,
    indexed_by<"byprprate"_n, const_mem_fun<contributor, uint64_t, &contributor::by_propertor_rating>>,
    indexed_by<"byrating"_n, const_mem_fun<contributor, uint64_t, &contributor::by_rating>>
> contributor_index;
}// namespace Capital
 
namespace Capital::Contributors {
 
  namespace Status {
    const eosio::name PENDING = "pending"_n;       
    const eosio::name ACTIVE = "active"_n; 
    const eosio::name IMPORT = "import"_n; 
  }
  
  inline void create_contributor(eosio::name coopname, eosio::name username, checksum256 contributor_hash, bool is_external_contract, document2 contract, eosio::asset rate_per_hour, uint64_t hours_per_day){
    Capital::contributor_index contributors(_capital, coopname.value);
   
    contributors.emplace(RamPayer::of(contributors, coopname), [&](auto &c) {
      c.id = get_global_id_in_scope(_capital, coopname, "contributors"_n);
      c.coopname = coopname;
      c.username = username;
      c.contributor_hash = contributor_hash;
      c.status = Capital::Contributors::Status::PENDING;
      c.is_external_contract = is_external_contract;
      c.contract = contract;
      c.created_at = eosio::current_time_point();
      c.rate_per_hour = rate_per_hour;
      c.hours_per_day = hours_per_day;
      
      // Инициализация геймификации
      c.level = 1;
      c.energy = 99.9999999999;
      c.last_energy_update = eosio::current_time_point();
    });
  }
  
  
  inline void import_contributor(
    eosio::name coopname,
    eosio::name username,
    checksum256 contributor_hash,
    eosio::asset contribution_amount,
    std::string memo
  ) {
    Capital::contributor_index contributors(_capital, coopname.value);
 
    contributors.emplace(RamPayer::of(contributors, coopname), [&](auto &c) {
      c.id = get_global_id_in_scope(_capital, coopname, "contributors"_n);
      c.coopname = coopname;
      c.username = username;
      c.contributor_hash = contributor_hash;
      c.status = Capital::Contributors::Status::IMPORT;
      c.is_external_contract = true;
      c.created_at = eosio::current_time_point();
      c.memo = memo;
      c.rate_per_hour = asset(0, _root_govern_symbol);
      c.hours_per_day = 0;
      c.contributed_as_investor = contribution_amount;
 
      // Инициализация геймификации
      c.level = 1;
      c.energy = 99.9999999999;
      c.last_energy_update = eosio::current_time_point();
    });
  }
  
  
  inline void push_appendix_to_contributor(eosio::name coopname, uint64_t contributor_id, checksum256 project_hash){
    contributor_index contributors(_capital, coopname.value);
    auto contributor_itr = contributors.find(contributor_id);
    eosio::check(contributor_itr != contributors.end(), "Контрибьютор не найден");
    
    contributors.modify(contributor_itr, RamPayer::of(contributors, coopname), [&](auto &c) {
      c.appendixes.push_back(project_hash);
    });
  }
 
  inline std::optional<contributor> get_contributor(eosio::name coopname, eosio::name username) {
    contributor_index contributors(_capital, coopname.value);
    auto username_index = contributors.get_index<"byusername"_n>();
 
    auto itr = username_index.find(username.value);
    if (itr == username_index.end()) {
        return std::nullopt;
    }
 
    return contributor(*itr);
  }
 
 
 
 
 inline std::optional<contributor> get_contributor_by_hash(eosio::name coopname, const checksum256& contributor_hash) {
  contributor_index contributors(_capital, coopname.value);
  auto hash_index = contributors.get_index<"byhash"_n>();
 
  auto itr = hash_index.find(contributor_hash);
  if (itr == hash_index.end()) {
      return std::nullopt;
  }
 
  return contributor(*itr);
}
 
 
inline bool is_contributor_has_appendix_in_project(eosio::name coopname, const checksum256 &project_hash, uint64_t contributor_id) {
  contributor_index contributors(_capital, coopname.value);
  auto contributor = contributors.find(contributor_id);
  
  if (contributor == contributors.end()) {
      return false;
  }
  
  // Проверяем есть ли project_hash в векторе appendixes
  for (const auto& appendix_project_hash : contributor->appendixes) {
      if (appendix_project_hash == project_hash) {
          return true;
      }
  }
  
  return false;
}
 
 
inline std::optional<contributor> get_active_contributor_or_fail(eosio::name coopname, eosio::name username) {
  auto contributor = get_contributor(coopname, username);
  eosio::check(contributor.has_value(), "Исполнитель не подписывал договор УХД");
  eosio::check(contributor -> status == Status::ACTIVE, "Договор УХД с пайщиком не активен");
  return contributor;
}
 
 
inline std::optional<contributor> get_active_contributor_with_appendix_or_fail(eosio::name coopname, const checksum256 &project_hash, eosio::name username) {
  auto contributor = get_active_contributor_or_fail(coopname, username);
  eosio::check(is_contributor_has_appendix_in_project(coopname, project_hash, contributor->id), 
               "Пайщик не подписывал приложение к договору УХД для данного проекта");
  return contributor;
}
 
inline std::optional<contributor> get_contributor_for_regshare_or_fail(eosio::name coopname, eosio::name username) {
  auto contributor = get_contributor(coopname, username);
  eosio::check(contributor.has_value(), "Исполнитель не подписывал договор УХД");
  const eosio::name st = contributor->status;
  eosio::check(st == Status::ACTIVE || st == Status::IMPORT,
               "Договор УХД с пайщиком не в статусе active или import");
  return contributor;
}
 
inline std::optional<contributor> get_contributor_for_program_invest_or_fail(eosio::name coopname, eosio::name username) {
  auto contributor = get_contributor(coopname, username);
  eosio::check(contributor.has_value(), "Исполнитель не подписывал договор УХД");
  return contributor;
}
 
 
 
inline void update_contributor_ratings_from_segment(eosio::name coopname, uint64_t contributor_id, const Capital::Segments::segment& segment) {
  Capital::contributor_index contributors(_capital, coopname.value);
  auto contributor = contributors.find(contributor_id);
 
  eosio::check(contributor != contributors.end(), "Контрибьютор не найден");
  
  contributors.modify(contributor, RamPayer::of(contributors, coopname), [&](auto &c) {
    // ВАЖНО: contributed_as_investor НЕ обновляется здесь, так как обновляется в момент инвестиции (createinvest)
    // Это предотвращает двойное начисление для участников с несколькими ролями (инвестор+создатель/автор и т.д.)
    
    if (segment.is_author) {
      c.contributed_as_author += (segment.author_base + segment.author_bonus);
    }
    
    if (segment.is_creator) {
      c.contributed_as_creator += (segment.creator_base + segment.creator_bonus);
    }
    
    if (segment.is_coordinator) {
      c.contributed_as_coordinator += segment.coordinator_base;
    }
    
    if (segment.is_contributor) {
      c.contributed_as_contributor += segment.contributor_bonus;
    }
    
    if (segment.is_propertor) {
      c.contributed_as_propertor += segment.property_base;
    }
  });
  
  // Обновляем геймификацию (уровень и энергию) после обновления рейтингов
  Capital::Gamification::update_gamification_from_segment(coopname, contributor_id, segment);
}
 
inline void increase_debt_amount(eosio::name coopname, uint64_t contributor_id, eosio::asset amount) {
  contributor_index contributors(_capital, coopname.value);
  auto contributor = contributors.find(contributor_id);
  
  eosio::check(contributor != contributors.end(), "Контрибьютор не найден");
  //TODO: make coopname payer
  contributors.modify(contributor, RamPayer::of(contributors, coopname), [&](auto &c) {
    c.debt_amount += amount;
  });
}
 
 inline void decrease_debt_amount(eosio::name coopname, uint64_t contributor_id, eosio::asset amount) {
  contributor_index contributors(_capital, coopname.value);
  auto contributor = contributors.find(contributor_id);
 
  eosio::check(contributor != contributors.end(), "Контрибьютор не найден");
  eosio::check(contributor->debt_amount >= amount, "Недостаточно долга для погашения");
 
  //TODO: make coopname payer
  contributors.modify(contributor, RamPayer::of(contributors, coopname), [&](auto &c) {
    c.debt_amount -= amount;
  });
}
 
inline void edit_contributor(eosio::name coopname, uint64_t contributor_id, eosio::asset rate_per_hour, uint64_t hours_per_day) {
  contributor_index contributors(_capital, coopname.value);
  auto contributor = contributors.find(contributor_id);
 
  eosio::check(contributor != contributors.end(), "Участник не найден");
 
  contributors.modify(contributor, RamPayer::of(contributors, coopname), [&](auto &c) {
    c.rate_per_hour = rate_per_hour;
    c.hours_per_day = hours_per_day;
  });
}
 
inline void increase_investor_contribution(eosio::name coopname, uint64_t contributor_id, eosio::asset amount) {
  contributor_index contributors(_capital, coopname.value);
  auto contributor = contributors.find(contributor_id);
 
  eosio::check(contributor != contributors.end(), "Участник не найден");
 
  contributors.modify(contributor, RamPayer::of(contributors, coopname), [&](auto &c) {
    c.contributed_as_investor += amount;
  });
}
 
inline void complete_imported_contributor_registration(
  eosio::name coopname, 
  uint64_t contributor_id, 
  eosio::asset rate_per_hour, 
  uint64_t hours_per_day,
  bool is_external_contract,
  document2 contract
) {
  contributor_index contributors(_capital, coopname.value);
  auto contributor = contributors.find(contributor_id);
 
  eosio::check(contributor != contributors.end(), "Участник не найден");
  eosio::check(contributor->status == Status::IMPORT, "Участник не находится в статусе импорта");
  eosio::check(contributor->is_external_contract == is_external_contract, "Флаг внешнего контракта не совпадает с импортированным");
 
  contributors.modify(contributor, RamPayer::of(contributors, coopname), [&](auto &c) {
    c.rate_per_hour = rate_per_hour;
    c.hours_per_day = hours_per_day;
    // Для не внешних контрактов обновляем contract
    if (!is_external_contract) {
      c.contract = contract;
    }
    c.status = Status::PENDING; // Меняем статус на PENDING для одобрения председателем
  });
}
 
 
}// namespace Capital::Contributors
 
// Плательщик за оперативную память строк таблицы — правило в lib/core/ram_payer.hpp.
RAM_PAYER_CLASS(Capital::contributor, contract);