segments.hpp

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

#pragma once
 
 
#include "../../../lib/core/ram_payer.hpp"
#include <eosio/eosio.hpp>
#include <eosio/asset.hpp>
 
using namespace eosio;
 
namespace Capital::Segments {
   namespace Status {
    const eosio::name GENERATION = "generation"_n;         
    const eosio::name READY = "ready"_n;                   
    const eosio::name STATEMENT = "statement"_n;           
    const eosio::name APPROVED = "approved"_n;             
    const eosio::name AUTHORIZED = "authorized"_n;         
    const eosio::name ACT1 = "act1"_n;                     
    const eosio::name CONTRIBUTED = "contributed"_n;       
    const eosio::name SKIPPED = "skipped"_n;       
  }
  
  struct [[eosio::table, eosio::contract(CAPITAL)]] segment {
    uint64_t id;                                          
    checksum256 project_hash;                             
    eosio::name coopname;                                 
    eosio::name username;                                 
    
    // Статус результата сегмента
    eosio::name status = Status::GENERATION;              
 
    // Роли участника в проекте
    bool is_author = false;                               
    bool is_creator = false;                              
    bool is_coordinator = false;                          
    bool is_investor = false;                             
    bool is_propertor = false;                            
    bool is_contributor = false;                          
    bool has_vote = false;                                
    
    // Основная информация о вкладе инвестора
    eosio::asset investor_amount = asset(0, _root_govern_symbol); 
    eosio::asset investor_base = asset(0, _root_govern_symbol);   
    
    // Основная информация о вкладе создателя
    eosio::asset creator_base = asset(0, _root_govern_symbol);    
    eosio::asset creator_bonus = asset(0, _root_govern_symbol);   
    
    // Основная информация о вкладе автора
    eosio::asset author_base = asset(0, _root_govern_symbol);     
    eosio::asset author_bonus = asset(0, _root_govern_symbol);    
    
    // Основная информация о вкладе координатора
    eosio::asset coordinator_investments = asset(0, _root_govern_symbol); 
    eosio::asset coordinator_base = asset(0, _root_govern_symbol);        
    
    // Основная информация о вкладе участника
    eosio::asset contributor_bonus = asset(0, _root_govern_symbol);       
    
    // Имущественные взносы
    eosio::asset property_base = asset(0, _root_govern_symbol);           
      
    // CRPS поля для масштабируемого распределения наград
    double last_author_base_reward_per_share = 0.0;                       
    double last_author_bonus_reward_per_share = 0.0;                      
    double last_contributor_reward_per_share = 0.0;                       
 
    // Доли в программе и проекте
    eosio::asset capital_contributor_shares = asset(0, _root_govern_symbol); 
    
    // Последняя известная сумма инвестиций в проекте для расчета provisional_amount
    eosio::asset last_known_invest_pool = asset(0, _root_govern_symbol);     
    
    // Последняя известная сумма базового пула создателей для расчета использования инвестиций
    eosio::asset last_known_creators_base_pool = asset(0, _root_govern_symbol); 
    
    // Последняя известная сумма инвестиций координаторов для отслеживания изменений
    eosio::asset last_known_coordinators_investment_pool = asset(0, _root_govern_symbol); 
    
    // Финансовые данные для ссуд
    eosio::asset provisional_amount = asset(0, _root_govern_symbol);       
    eosio::asset debt_amount = asset(0, _root_govern_symbol);              
    eosio::asset debt_settled = asset(0, _root_govern_symbol);             
    
    // Пулы равных премий авторов и прямых премий создателей
    eosio::asset equal_author_bonus = asset(0, _root_govern_symbol);       
    eosio::asset direct_creator_bonus = asset(0, _root_govern_symbol);     
    
    // Результаты голосования по методу Водянова
    bool is_votes_calculated = false;                                      
    eosio::asset voting_bonus = asset(0, _root_govern_symbol);             
    
    // Общая стоимость сегмента (рассчитывается автоматически)
    eosio::asset total_segment_base_cost = asset(0, _root_govern_symbol);  
    eosio::asset total_segment_bonus_cost = asset(0, _root_govern_symbol); 
    eosio::asset total_segment_cost = asset(0, _root_govern_symbol);       
    
    // Интеллектуальная стоимость сегмента и доля в результате
    eosio::asset intellectual_cost = asset(0, _root_govern_symbol);        
    eosio::asset available_for_program = asset(0, _root_govern_symbol); 
    eosio::asset available_for_wallet = asset(0, _root_govern_symbol); 
    double share_percent = 0.0;                                            
    
    uint64_t primary_key() const { return id; }                           
    
    checksum256 by_project_hash() const { return project_hash; }          
  
    // Индекс по (project_hash + username) - уникальный для каждого участника проекта
    uint128_t by_project_user() const {                                   
        return combine_checksum_ids(project_hash, username);
    }
    
  };
  
  typedef eosio::multi_index<
    "segments"_n, segment,
    indexed_by<"byproject"_n, const_mem_fun<segment, checksum256, &segment::by_project_hash>>,
    indexed_by<"byprojuser"_n, const_mem_fun<segment, uint128_t, &segment::by_project_user>>
  > segments_index;
 
  
  inline std::optional<segment> get_segment(eosio::name coopname, const checksum256 &project_hash, eosio::name username) {
    segments_index segments(_capital, coopname.value);
    auto idx  = segments.get_index<"byprojuser"_n>();
    auto rkey = combine_checksum_ids(project_hash, username);
 
    auto it = idx.find(rkey);
    if (it == idx.end()) {
        return std::nullopt;
    }
    return segment(*it);
  }
 
  inline segment get_segment_or_fail(eosio::name coopname, const checksum256 &project_hash, eosio::name username, const char* msg) {
    auto maybe_segment = get_segment(coopname, project_hash, username);
    eosio::check(maybe_segment.has_value(), msg);
    return maybe_segment.value();
  }
 
  inline segment get_segment_by_id_or_fail(eosio::name coopname, uint64_t segment_id, const char* msg = "Сегмент не найден") {
    segments_index segments(_capital, coopname.value);
    auto segment_itr = segments.find(segment_id);
    eosio::check(segment_itr != segments.end(), msg);
    return segment(*segment_itr);
  }
 
 
inline uint64_t count_project_authors(eosio::name coopname, const checksum256 &project_hash) {
    segments_index segments(_capital, coopname.value);
    auto project_idx = segments.get_index<"byproject"_n>();
    
    // Собираем ID сначала, потом считаем
    std::vector<uint64_t> author_ids;
    {
        auto itr = project_idx.find(project_hash);
        while (itr != project_idx.end() && itr->project_hash == project_hash) {
            if (itr->is_author) {
                author_ids.push_back(itr->id); // Сохраняем ID, а не итератор
            }
            ++itr;
        }
    } // Итератор уничтожен
    
    return author_ids.size();
}
 
 
 
inline bool is_voting_participant(eosio::name coopname, const checksum256 &project_hash, eosio::name username) {
    auto segment = get_segment(coopname, project_hash, username);
    return segment.has_value() && segment->has_vote;
}
 
inline bool is_pure_investor(const segment& seg) {
    return seg.is_investor && 
           !seg.is_author && 
           !seg.is_creator && 
           !seg.is_coordinator && 
           !seg.is_propertor;
}
 
inline bool has_intellectual_contribution_roles(const segment& seg) {
    return seg.is_author || 
           seg.is_creator || 
           seg.is_coordinator || 
           seg.is_propertor || 
           seg.is_contributor;
}
 
inline eosio::asset calculate_non_investor_contribution(const segment& seg) {
    // Базовые вклады (без investor_base, так как он уже внесен при инвестировании)
    eosio::asset base_contribution = seg.creator_base + seg.author_base + seg.coordinator_base + seg.property_base;
    
    // Бонусы (премии) только для интеллектуальных ролей
    eosio::asset bonus_contribution = seg.creator_bonus + seg.author_bonus + 
                                     seg.equal_author_bonus + seg.direct_creator_bonus + 
                                     seg.voting_bonus + seg.contributor_bonus;
    
    return base_contribution + bonus_contribution;
}
 
inline eosio::asset calculate_segment_base_cost(const segment& seg) {
    eosio::asset total = asset(0, _root_govern_symbol);
    
    // Базовые вклады (всегда учитываются)
    total += seg.investor_base; // фактически используемая сумма инвестора
    total += seg.creator_base;
    total += seg.author_base;
    total += seg.coordinator_base;
    total += seg.property_base; // стоимость внесенного имущества
    
    return total;
}
 
inline eosio::asset calculate_segment_bonus_cost(const segment& seg, const Capital::project& project) {
    eosio::asset total = asset(0, _root_govern_symbol);
    
    // Премии зависят от статуса проекта
    if (project.status == Capital::Projects::Status::RESULT) {
        // После голосования используем результаты голосования
        total += seg.equal_author_bonus;
        total += seg.direct_creator_bonus;
        total += seg.voting_bonus;
    } else {
        // До голосования используем полные суммы премий
        total += seg.creator_bonus;
        total += seg.author_bonus;
    }
    
    // Премии участников
    total += seg.contributor_bonus;
    
    return total;
}
 
inline void update_segment_total_cost(eosio::name coopname, uint64_t segment_id, const Capital::project &project) {
    segments_index segments(_capital, coopname.value);
    auto segment = segments.find(segment_id);
    
    eosio::check(segment != segments.end(), "Сегмент участника не найден");
    
    segments.modify(segment, RamPayer::of(segments, coopname), [&](auto &s) {
        s.total_segment_base_cost = calculate_segment_base_cost(s);
        s.total_segment_bonus_cost = calculate_segment_bonus_cost(s, project);
        s.total_segment_cost = s.total_segment_base_cost + s.total_segment_bonus_cost;
        
        eosio::check(s.total_segment_cost >= s.investor_base, "Сумма всех вкладов сегмента должна быть больше или равна сумме инвестиций инвестора");
        
        // Интеллектуальная стоимость = полная стоимость минус обеспечительный взнос инвестора
        s.intellectual_cost = s.total_segment_cost - s.investor_base;
        
        eosio::check(s.intellectual_cost >= s.debt_amount, "Интеллектуальная стоимость должна быть больше или равна сумме выданных ссуд");
        // Доступная сумма для конвертации в программу
        s.available_for_program = s.intellectual_cost - s.debt_amount;
        
        eosio::check(s.provisional_amount >= s.debt_amount, "Доступная сумма для конвертации в кошелек должна быть больше или равна сумме выданных ссуд");
        // Доступная сумма для конвертации в кошелек
        s.available_for_wallet = s.provisional_amount - s.debt_amount;
 
        // Доля участника в результате интеллектуальной деятельности
        if (project.fact.total.amount > 0) {
            s.share_percent = (static_cast<double>(s.intellectual_cost.amount) / 
                              static_cast<double>(project.fact.total.amount)) * 100.0;
        } else {
            s.share_percent = 0.0;
        }
    });
}
 
  inline void update_segment_status(eosio::name coopname, const checksum256 &project_hash, 
                                        eosio::name username, eosio::name new_status) {
    segments_index segments(_capital, coopname.value);
    auto idx = segments.get_index<"byprojuser"_n>();
    auto key = combine_checksum_ids(project_hash, username);
    auto segment_itr = idx.find(key);
    
    eosio::check(segment_itr != idx.end(), "Сегмент участника не найден");
    
    idx.modify(segment_itr, RamPayer::of(idx, coopname), [&](auto &s) {
        s.status = new_status;
    });
}
 
inline void update_segment_after_result_contribution(eosio::name coopname, const checksum256 &project_hash, 
                                                               eosio::name username,
                                                               eosio::asset debt_settled_amount = asset(0, _root_govern_symbol)) {
    segments_index segments(_capital, coopname.value);
    auto idx = segments.get_index<"byprojuser"_n>();
    auto key = combine_checksum_ids(project_hash, username);
    auto segment_itr = idx.find(key);
    
    eosio::check(segment_itr != idx.end(), "Сегмент участника не найден");
    
    idx.modify(segment_itr, RamPayer::of(idx, coopname), [&](auto &s) {
        // Обновляем после принятия результата
        s.status = Capital::Segments::Status::STATEMENT;
        
        // Если есть погашение долга, отмечаем его
        if (debt_settled_amount.amount > 0) {
            s.debt_settled += debt_settled_amount;
        }
    });
}
 
 
inline uint64_t get_segment_id(eosio::name coopname) {
  return get_global_id_in_scope(_capital, coopname, "segments"_n);
}
 
inline void update_segment_voting_results(eosio::name coopname, const Capital::project &project, 
                                         const segment &segment,
                                         eosio::name username,
                                         eosio::asset voting_amount,
                                         eosio::asset equal_author_amount,
                                         eosio::asset direct_creator_amount) {
    segments_index segments(_capital, coopname.value);
    auto segment_itr = segments.find(segment.id);
    
    eosio::check(segment_itr != segments.end(), "Сегмент участника не найден");
    
    segments.modify(segment_itr, RamPayer::of(segments, coopname), [&](auto &s) {
        s.voting_bonus = voting_amount;
        s.equal_author_bonus = equal_author_amount;
        s.direct_creator_bonus = direct_creator_amount;
        s.is_votes_calculated = true;
    });
    
    // Обновляем общую стоимость сегмента после изменения премий
    update_segment_total_cost(coopname, segment_itr->id, project);
}
 
inline void set_investor_base_amount_on_return_unused(eosio::name coopname, uint64_t segment_id, eosio::asset used_amount) {
  Capital::Segments::segments_index segments(_capital, coopname.value);
  auto segment_itr = segments.find(segment_id);
 
  segments.modify(segment_itr, RamPayer::of(segments, coopname), [&](auto &s) {
    // Обновляем общую сумму инвестора до фактически использованной
    s.investor_amount = used_amount;
    // Также обновляем фактически используемую сумму инвестора для корректного расчета total_segment_cost
    s.investor_base = used_amount;
  });
 
}
 
inline void increase_debt_amount(eosio::name coopname, uint64_t segment_id, eosio::asset amount) {
  Capital::Segments::segments_index segments(_capital, coopname.value);
  auto segment = segments.find(segment_id);
  
  segments.modify(segment, RamPayer::of(segments, coopname), [&](auto &s) {
      s.debt_amount += amount;
  });
}
  
inline void decrease_debt_amount(eosio::name coopname, uint64_t segment_id, eosio::asset amount) {
  Capital::Segments::segments_index segments(_capital, coopname.value);
  auto segment = segments.find(segment_id);
  
  eosio::check(segment->debt_amount >= amount, "Пайщик не может погасить долг больше, чем должен");
  
  segments.modify(segment, RamPayer::of(segments, coopname), [&](auto &s) {
    s.debt_amount -= amount;
  });
}
 
inline void remove_segment(eosio::name coopname, uint64_t segment_id) {
  segments_index segments(_capital, coopname.value);
  auto segment = segments.find(segment_id);
  
  eosio::check(segment != segments.end(), "Сегмент участника не найден");
  
  segments.erase(segment);
 
}
 
inline void remove_all_project_segments(eosio::name coopname, const checksum256 &project_hash) {
  segments_index segments(_capital, coopname.value);
  auto project_idx = segments.get_index<"byproject"_n>();
  std::vector<uint64_t> ids;
  {
    auto itr = project_idx.find(project_hash);
    while (itr != project_idx.end() && itr->project_hash == project_hash) {
      ids.push_back(itr->id);
      ++itr;
    }
  }
  for (uint64_t id : ids) {
    remove_segment(coopname, id);
  }
}
 
inline void create_author_segment(eosio::name coopname, eosio::name username,  const Capital::project &project) {
  segments_index segments(_capital, coopname.value);
 
  segments.emplace(RamPayer::of(segments, coopname), [&](auto &g){
    g.id            = get_global_id_in_scope(_capital, coopname, "segments"_n);
    g.coopname      = coopname;
    g.project_hash  = project.project_hash;
    g.username      = username;
    g.is_author     = true;
    g.has_vote      = true;
    // Инициализируем CRPS поля
    g.last_author_base_reward_per_share = project.crps.author_base_cumulative_reward_per_share;
    g.last_author_bonus_reward_per_share = project.crps.author_bonus_cumulative_reward_per_share;
  });
}
 
inline void update_segment_author_status(eosio::name coopname, uint64_t segment_id, const Capital::project &project) {
  segments_index segments(_capital, coopname.value);
  auto segment = segments.find(segment_id);
 
  eosio::check(segment != segments.end(), "Сегмент участника не найден");
 
  segments.modify(segment, RamPayer::of(segments, coopname), [&](auto &g) {
    if (!g.is_author) {
      g.is_author = true;
      // Инициализируем CRPS поля для нового автора
      g.last_author_base_reward_per_share = project.crps.author_base_cumulative_reward_per_share;
      g.last_author_bonus_reward_per_share = project.crps.author_bonus_cumulative_reward_per_share;
    }
  });
}
 
inline bool has_project_segments(eosio::name coopname, const checksum256 &project_hash) {
  segments_index segments(_capital, coopname.value);
  auto idx = segments.get_index<"byproject"_n>();
  auto it = idx.lower_bound(project_hash);
 
  return it != idx.end() && it->project_hash == project_hash;
}
 
} // namespace Capital::Segments
 
// Плательщик за оперативную память строк таблицы — правило в lib/core/ram_payer.hpp.
RAM_PAYER_CLASS(Capital::Segments::segment, contract);