program_properties.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::ProgramProperties {
   namespace Status {
    constexpr eosio::name CREATED = "created"_n;     
    constexpr eosio::name APPROVED = "approved"_n;   
    constexpr eosio::name AUTHORIZED = "authorized"_n; 
    constexpr eosio::name ACT1 = "act1"_n;          
    constexpr eosio::name ACT2 = "act2"_n;          
  }
}
 
namespace Capital::ProgramProperties {
 
  struct [[eosio::table, eosio::contract(CAPITAL)]] program_property {
    uint64_t id;                                 
    name coopname;                               
    name username;                               
    name status;                                 
    checksum256 property_hash;                   
    eosio::asset property_amount;                
    std::string property_description;            
    document2 statement;                         
    document2 authorization;                     
    document2 act;                              
    time_point_sec created_at;                   
 
    uint64_t primary_key() const { return id; } 
    uint64_t by_username() const { return username.value; } 
    checksum256 by_property_hash() const { return property_hash; } 
  };
 
typedef eosio::multi_index<
    "pgproperties"_n, program_property,
    indexed_by<"byusername"_n, const_mem_fun<program_property, uint64_t, &program_property::by_username>>,
    indexed_by<"byhash"_n, const_mem_fun<program_property, checksum256, &program_property::by_property_hash>>
> program_property_index;
 
 inline std::optional<program_property> get_program_property(eosio::name coopname, const checksum256 &hash) {
  program_property_index properties(_capital, coopname.value);
  auto property_hash_index = properties.get_index<"byhash"_n>();
 
  auto itr = property_hash_index.find(hash);
  if (itr == property_hash_index.end()) {
      return std::nullopt;
  }
 
  return program_property(*itr);
}
 
 inline program_property get_program_property_or_fail(eosio::name coopname, const checksum256 &hash) {
  auto property = get_program_property(coopname, hash);
  eosio::check(property.has_value(), "Предложение по программному имущественному взносу не найдено");
 
  return property.value();
}
 
inline void delete_program_property(eosio::name coopname, uint64_t property_id) {
  program_property_index properties(_capital, coopname.value);
  auto property = properties.find(property_id);
  eosio::check(property != properties.end(), "Предложение по программному имущественному взносу не найдено");
 
  properties.erase(property);
}
 
inline void create_program_property_with_approve(
  eosio::name coopname,
  eosio::name username,
  checksum256 property_hash,
  const eosio::asset &property_amount,
  const std::string &property_description,
  const document2 &statement
) {
  // Создаем предложение
  program_property_index properties(_capital, coopname.value);
  auto property_id = get_global_id_in_scope(_capital, coopname, "pgproperties"_n);
  
  // Создаем предложение в таблице pgproperties
  properties.emplace(RamPayer::of(properties, coopname), [&](auto &p) {
    p.id = property_id;
    p.status = Capital::ProgramProperties::Status::CREATED;
    p.coopname = coopname;
    p.username = username;
    p.property_hash = property_hash;
    p.property_amount = property_amount;
    p.property_description = property_description;
    p.statement = statement;
    p.created_at = current_time_point();
  });
 
  // Отправляем на approve председателю
  ::Soviet::create_approval(
    _capital,
    coopname,
    username,
    statement,
    Names::Capital::CREATE_PROGRAM_PROPERTY,
    property_hash,
    _capital,
    Names::Capital::APPROVE_PROGRAM_PROPERTY,
    Names::Capital::DECLINE_PROGRAM_PROPERTY,
    std::string("")
  );
}
 
inline void update_program_property_status(eosio::name coopname, uint64_t property_id, eosio::name new_status) {
  program_property_index properties(_capital, coopname.value);
  auto property = properties.find(property_id);
  eosio::check(property != properties.end(), "Предложение по программному имущественному взносу не найдено");
  
  properties.modify(property, RamPayer::of(properties, coopname), [&](auto &p) {
    p.status = new_status;
  });
}
 
inline void set_program_property_approved_statement(eosio::name coopname, uint64_t property_id, const document2 &approved_statement) {
  program_property_index properties(_capital, coopname.value);
  auto property = properties.find(property_id);
  
  eosio::check(property != properties.end(), "Предложение по программному имущественному взносу не найдено");
  
  properties.modify(property, RamPayer::of(properties, coopname), [&](auto &p) {
    p.statement = approved_statement;
  });
}
 
inline void set_program_property_authorization(eosio::name coopname, uint64_t property_id, const document2 &authorization) {
  program_property_index properties(_capital, coopname.value);
  auto property = properties.find(property_id);
  eosio::check(property != properties.end(), "Предложение по программному имущественному взносу не найдено");
  
  properties.modify(property, RamPayer::of(properties, coopname), [&](auto &p) {
    p.authorization = authorization;
  });
}
 
inline void set_program_property_act1(eosio::name coopname, uint64_t property_id, const document2 &act1) {
  program_property_index properties(_capital, coopname.value);
  auto property = properties.find(property_id);
  eosio::check(property != properties.end(), "Предложение по программному имущественному взносу не найдено");
  
  properties.modify(property, RamPayer::of(properties, coopname), [&](auto &p) {
    p.act = act1;
  });
}
 
inline void set_program_property_act2(eosio::name coopname, uint64_t property_id, const document2 &act2) {
  program_property_index properties(_capital, coopname.value);
  auto property = properties.find(property_id);
  eosio::check(property != properties.end(), "Предложение по программному имущественному взносу не найдено");
  
  properties.modify(property, RamPayer::of(properties, coopname), [&](auto &p) {
    p.act = act2;
  });
}
 
} // namespace Capital::ProgramProperties
 
// Плательщик за оперативную память строк таблицы — правило в lib/core/ram_payer.hpp.
RAM_PAYER_CLASS(Capital::ProgramProperties::program_property, cooperative);