1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use near_sdk::AccountId;
use near_sdk::json_types::{ U128 };
use crate::referral::{ ReferralFeature, ReferralEnumeration, InfluencerId, ContractId, ProgramId };
use crate::referral::utils::get_program_id;

impl ReferralEnumeration for ReferralFeature {
    fn referrals_by_contract(&self, contract_id: AccountId) -> Vec<AccountId> {
        if let Some(referrals) = self.referrals_by_contract.get(&contract_id) {
            referrals.to_vec()
        } else {
            vec![]
        }
    }

    fn referrals_supply_by_contract(&self, contract_id: AccountId) -> u128 {
        if let Some(referrals) = self.referrals_by_contract.get(&contract_id) {
            referrals.len() as u128
        } else {
            0
        }
    }

    fn referrals_by_program(
        &self,
        contract_id: AccountId,
        influencer_id: AccountId,
        program_id: String
    ) -> Vec<AccountId> {
        let id = get_program_id(&contract_id, &influencer_id, &program_id);

        if let Some(referrals) = self.referrals_by_program.get(&id) {
            referrals.to_vec()
        } else {
            vec![]
        }
    }

    fn referrals_supply_by_program(
        &self,
        contract_id: AccountId,
        influencer_id: AccountId,
        program_id: String
    ) -> u128 {
        let id = get_program_id(&contract_id, &influencer_id, &program_id);

        if let Some(referrals) = self.referrals_by_program.get(&id) {
            referrals.len() as u128
        } else {
            0
        }
    }

    fn referrals_by_influencer(&self, influencer_id: InfluencerId) -> Vec<AccountId> {
        if let Some(referrals) = self.referrals_by_contract.get(&influencer_id) {
            referrals.to_vec()
        } else {
            vec![]
        }
    }

    fn referrals_supply_by_influencer(&self, influencer_id: InfluencerId) -> u128 {
        if let Some(referrals) = self.referrals_by_influencer.get(&influencer_id) {
            referrals.len() as u128
        } else {
            0
        }
    }

    fn referral_contracts_by_influencer(&self, influencer_id: InfluencerId) -> Vec<ContractId> {
        if let Some(contracts) = self.programs_by_influencer.get(&influencer_id) {
            contracts
                .iter()
                .map(|(key, value)| { key })
                .collect()
        } else {
            vec![]
        }
    }

    fn referral_programs_by_influencer(
        &self,
        influencer_id: InfluencerId,
        contract_id: ContractId
    ) -> Vec<ProgramId> {
        if let Some(contracts) = self.programs_by_influencer.get(&influencer_id) {
            if let Some(programs) = contracts.get(&contract_id) {
                programs.to_vec()
            } else {
                vec![]
            }
        } else {
            vec![]
        }
    }

    fn referral_influencers_by_contract(&self, contract_id: ContractId) -> Vec<InfluencerId> {
        if let Some(influencers) = self.programs_by_contract.get(&contract_id) {
            influencers
                .iter()
                .map(|(key, value)| { key })
                .collect()
        } else {
            vec![]
        }
    }

    fn referral_programs_by_contract(
        &self,
        contract_id: InfluencerId,
        influencer_id: InfluencerId
    ) -> Vec<ProgramId> {
      let influencers = self.programs_by_contract.get(&contract_id).expect("Not found");
        if let Some(programs) = influencers.get(&influencer_id) {
          programs.to_vec()
        } else {
          vec![]
        }
    }
}