coops.hpp

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

#pragma once
struct board_member {
  eosio::name username; 
  bool is_voting; 
  std::string position_title; 
  eosio::name position; 
  // (CHAIRMAN, _('chairman')),
  // (CHAIRMAN_VP, _('vpchairman')),
  // (SECRETARY, _('secretary')),
  // (ACCOUNTING, _('accounting')),
  // (MEMBER, _('member')),
  // (INVITED, _(‘invited')),
};
 
struct [[eosio::table, eosio::contract(SOVIET)]] boards {
  uint64_t id; 
  eosio::name type; 
  // (soviet, _('Board of Members')),   # Совет кооператива
  // (executive, _('Executive Board')), # Правление
  // (audit, _('Audit and Revision Board')),  # Ревизионный
  // (other, _('Other committee')),   # Другая комиссия
  std::string name; 
  std::string description; 
  
  std::vector<board_member> members; 
 
  eosio::time_point_sec created_at; 
  eosio::time_point_sec last_update; 
 
 
  uint64_t primary_key() const { return id; }
 
  uint64_t by_type() const { return type.value; }
 
  bool is_valid_member(eosio::name member) const {
    for (const auto& m : members) {
      if (m.username == member)
        return true;
    }
    return false;
  }
 
  bool is_voting_member(eosio::name member) const {
    for (const auto& m : members) {
      if (m.username == member && m.is_voting == true)
        return true;
    }
    return false;
  }
 
 
  bool is_valid_chairman(eosio::name chairman) const {
    for (const auto& m : members) {
      if (m.username == chairman && (m.position == "chairman"_n || m.position == "vpchairman"_n))
        return true;
    }
    return false;
  }
 
  eosio::name get_chairman() const {
    for (const auto& m : members) {
      if (m.position == "chairman"_n)
        return m.username;
    }
    return ""_n;
  };
 
  bool is_valid_secretary(eosio::name secretary) const {
    for (const auto& m : members) {
      if (m.username == secretary && (m.position == "secretary"_n))
        return true;
    }
    return false;
  }
 
  bool has_voting_right(eosio::name member) const {
    for (const auto& m : members) {
        if (m.username == member && m.is_voting)
            return true;
    }
    return false;
  }
 
 
  uint64_t get_members_count() const {
    return members.size();
  };
 
};
 
typedef eosio::multi_index< "boards"_n, boards,
eosio::indexed_by<"bytype"_n, eosio::const_mem_fun<boards, uint64_t,
                                                       &boards::by_type>>> boards_index;
 
 
struct right {
  eosio::name contract; 
  eosio::name action_name; 
};
 
struct [[eosio::table, eosio::contract(SOVIET)]] staff {
  eosio::name username; 
  std::string position_title; 
  std::vector<eosio::name> roles; 
  std::vector<right> rights; 
  eosio::time_point_sec created_at; 
  eosio::time_point_sec updated_at; 
 
  uint64_t primary_key() const { return username.value; } 
 
  bool has_right(eosio::name contract, eosio::name action_name) const {
    for (const auto& r : rights) {
        if (r.contract == contract && r.action_name == action_name) {
            return true;
        }
    }
    return false;
  }
};
 
typedef eosio::multi_index<"staff"_n, staff> staff_index; 
 
 
struct [[eosio::table, eosio::contract(SOVIET)]] participant {
  eosio::name username; 
  eosio::time_point_sec created_at; 
  eosio::time_point_sec last_update; 
  eosio::time_point_sec last_min_pay; 
 
  eosio::name status; //accepted | blocked
 
  bool is_initial = true; 
  bool is_minimum = true; 
  bool has_vote = true; 
  
  eosio::binary_extension<eosio::name> type; 
  eosio::binary_extension<eosio::name> braname; 
 
  eosio::binary_extension<eosio::asset> initial_amount; 
  eosio::binary_extension<eosio::asset> minimum_amount; 
  
  uint64_t primary_key() const {
    return username.value;
  } 
  uint64_t bylastpay() const {
    return last_min_pay.sec_since_epoch();
  }
 
  uint64_t by_created_at() const {
    return created_at.sec_since_epoch();
  }
 
  bool is_active() const {
    return status == "accepted"_n;
  }
  
  uint64_t by_braname() const {
    return braname.has_value() ? braname -> value : 0; // Проверка на наличие значения
  }
 
};
 
typedef eosio::multi_index< "participants"_n, participant,
  eosio::indexed_by<"bylastpay"_n, eosio::const_mem_fun<participant, uint64_t, &participant::bylastpay>>,
  eosio::indexed_by<"createdat"_n, eosio::const_mem_fun<participant, uint64_t, &participant::by_created_at>>,
  eosio::indexed_by<"bybranch"_n, eosio::const_mem_fun<participant, uint64_t, &participant::by_braname>>
> participants_index;
 
 
struct [[eosio::table, eosio::contract(SOVIET)]] decision {
  uint64_t id; 
  eosio::name coopname; 
  eosio::name username; 
  
  eosio::name type; 
  uint64_t batch_id; 
  document2 statement; 
  
  std::vector<eosio::name> votes_for; 
  std::vector<eosio::name> votes_against; 
  
  bool validated = false; 
  bool approved = false; 
  bool authorized = false; 
  eosio::name authorized_by; 
  document2 authorization; 
 
  eosio::time_point_sec created_at; 
  
  eosio::binary_extension<eosio::time_point_sec> expired_at; 
  eosio::binary_extension<std::string> meta; 
  
  eosio::binary_extension<name> callback_contract; 
  eosio::binary_extension<name> confirm_callback; 
  eosio::binary_extension<name> decline_callback; 
  eosio::binary_extension<checksum256> hash; 
  
  uint64_t primary_key() const { return id; }
 
  uint64_t by_secondary() const { return batch_id; }
 
  uint64_t bytype() const { return type.value; }
 
  uint64_t byapproved() const { return approved; }
 
  uint64_t byvalidated() const { return validated; }
 
  uint64_t byauthorized() const { return authorized; }
 
  
  checksum256 byhash() const { return hash.value(); }
 
 
  void check_for_any_vote_exist(eosio::name member) const {
    // Проверяем, есть ли имя участника в голосах за
    eosio::check(std::find(votes_for.begin(), votes_for.end(), member) == votes_for.end(), "Участник уже голосовал за данное решение.");
 
    // Проверяем, есть ли имя участника в голосах против
    eosio::check(std::find(votes_against.begin(), votes_against.end(), member) == votes_against.end(), "Участник уже голосовал против данного решения.");
  };
 
  std::pair<uint64_t, uint64_t> get_votes_count() const {
    return std::make_pair(votes_for.size(), votes_against.size());
  };
};
 
 
typedef eosio::multi_index< "decisions"_n, decision,
  eosio::indexed_by<"bysecondary"_n, eosio::const_mem_fun<decision, uint64_t, &decision::by_secondary>>,
  eosio::indexed_by<"bytype"_n, eosio::const_mem_fun<decision, uint64_t, &decision::bytype>>,
  eosio::indexed_by<"byapproved"_n, eosio::const_mem_fun<decision, uint64_t, &decision::byapproved>>,
  eosio::indexed_by<"byvalidated"_n, eosio::const_mem_fun<decision, uint64_t, &decision::byvalidated>>,
  eosio::indexed_by<"byauthorized"_n, eosio::const_mem_fun<decision, uint64_t, &decision::byauthorized>>,
  eosio::indexed_by<"byhash"_n, eosio::const_mem_fun<decision, checksum256, &decision::byhash>>
> decisions_index;
 
 
boards get_board_by_id(eosio::name coopname, uint64_t board_id){
  boards_index boards(_soviet, coopname.value);
  auto board = boards.find(board_id);
  
  eosio::check(board != boards.end(), "Совет не найден");
 
  return *board; 
 
};
 
 
boards get_board_by_type_or_fail(eosio::name coopname, eosio::name type){
  boards_index boards(_soviet, coopname.value);
  auto boards_by_type_index = boards.template get_index<"bytype"_n>();
  auto exist = boards_by_type_index.find(type.value);
  
  eosio::check(exist != boards_by_type_index.end(), "Совет не найден");
 
  return *exist;
 
};
 
 
bool check_for_exist_board_by_type(eosio::name coopname, eosio::name type){
  boards_index boards(_soviet, coopname.value);
 
  auto boards_by_type_index = boards.template get_index<"bytype"_n>();
 
  auto exist = boards_by_type_index.find(type.value);
  
  if (exist != boards_by_type_index.end())
    return true;
  else return false;
}
 
struct address_data {
  std::string full_address;
  std::string latitude;
  std::string longitude;
  std::string country;
  std::string state;
  std::string city;
  std::string district;
  std::string street;
  std::string house_number;
  std::string building_section;
  std::string unit_number;
  std::string directions; //как добраться
  std::string phone_number;
  std::string email;
  std::string business_hours;  
  std::string meta;
};
 
 
struct [[eosio::table, eosio::contract(SOVIET)]] address {
  uint64_t id;
  eosio::name coopname;
  eosio::name braname;
  address_data data;
  
  uint64_t primary_key() const { return id; }
};
 
 
typedef eosio::multi_index< "addresses"_n, address> addresses_index;
 
 
 
bool is_valid_participant(eosio::name coopname, eosio::name username) {
  participants_index participants(_soviet, coopname.value);
  auto participant = participants.find(username.value);
  accounts_index accounts(_registrator, _registrator.value);
  auto account = accounts.find(username.value);
  
  if (
    participant != participants.end() && 
    participant->status == "accepted"_n
  ) 
  {
    return true;
  }
  
  return false;
}
 
 
participant get_participant_or_fail(eosio::name coopname, eosio::name username){
  participants_index participants(_soviet, coopname.value);
  auto participant = participants.find(username.value);
  eosio::check(participant != participants.end(), "Пайщик не найден в кооперативе");
  eosio::check(participant -> status != "blocked"_n, "Пайщик заблокирован");
  
  return *participant;
}