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

use super::constants;
use super::Segment;
use super::SegmentCondition;
use super::SegmentRule;
use crate::environments;
use crate::identities;

use crate::utils::hashing::get_hashed_percentage_for_object_ids;

pub fn get_identity_segments(
    environment: &environments::Environment,
    identity: &identities::Identity,
    override_traits: Option<&Vec<identities::Trait>>,
) -> Vec<Segment> {
    environment
        .project
        .segments
        .clone()
        .into_iter()
        .filter(|segment| evaluate_identity_in_segment(&identity, &segment, override_traits))
        .collect()
}

pub fn evaluate_identity_in_segment(
    identity: &identities::Identity,
    segment: &Segment,
    override_traits: Option<&Vec<identities::Trait>>,
) -> bool {
    let traits = override_traits.unwrap_or(&identity.identity_traits);
    let identity_id = match identity.django_id {
        Some(django_id) => django_id.to_string(),
        None => identity.composite_key(),
    };
    segment.rules.len() > 0
        && segment
            .rules
            .iter()
            .map(|rule| {
                traits_match_segment_rule(traits, rule, &segment.id.to_string(), &identity_id)
            })
            .all(|result| result)
}

fn traits_match_segment_rule(
    identity_traits: &Vec<identities::Trait>,
    rule: &SegmentRule,
    segment_id: &str,
    identity_id: &str,
) -> bool {
    let mut rules_iterator = rule.conditions.iter().map(|condition| {
        traits_match_segment_condition(&identity_traits, condition, segment_id, identity_id)
    });
    let matches_condtion = match rule.segment_rule_type.as_str() {
        constants::ANY_RULE => rules_iterator.any(|result| result == true),
        constants::ALL_RULE => rules_iterator.all(|result| result == true),
        constants::NONE_RULE => true,
        _ => false,
    };
    return matches_condtion
        && rule
            .rules
            .iter()
            .map(|rule| {
                traits_match_segment_rule(&identity_traits, rule.as_ref(), segment_id, identity_id)
            })
            .all(|result| result == true);
}
fn traits_match_segment_condition(
    identity_traits: &Vec<identities::Trait>,
    condition: &SegmentCondition,
    segment_id: &str,
    identity_id: &str,
) -> bool {
    if condition.operator == constants::PERCENTAGE_SPLIT {
        let float_value: f32 = condition.value.parse().unwrap();
        return get_hashed_percentage_for_object_ids(vec![segment_id, identity_id], 1)
            <= float_value;
    }
    match condition.property.clone() {
        Some(property) => {
            let identity_trait = identity_traits
                .iter()
                .filter(|identity_trait| identity_trait.trait_key == property)
                .next();
            match identity_trait {
                Some(_trait) => condition.matches_trait_value(&_trait.trait_value),
                None => false,
            }
        }
        None => false,
    }
}