validators

class IValidator(object):
    __metaclass__ = ABCMeta

    @abstractmethod
    def validate(self, site):
        """
        :type site: community.models.Site
        :rtype: bool
        """


class HasFieldsValidator(IValidator):
    def __init__(self, required_fields):
        self.required_fields = required_fields

    def validate(self, site):
        return all(map(self._has_a_valid_value, required_fields))

    def _has_a_valid_value(self, field):
        if field.startswith('specific_data.'):
            field_name = field.split('.')[1]
            return bool(self.site.specific_data.get(field_name))
        else:
            return bool(getattr(self.site, field))


class HasMoreFollowersThanValidator(IValidator):
    def __init__(self, min_followers_count):
        self.min_followers_count = min_followers_count

    def validate(self, site):
        followers_cnt = SiteFollow.get_site_followers_cnt(site.id)
        return followers_cnt >= self.min_followers_count


class HasLessFollowersThanValidator(IValidator):
    def __init__(self, max_followers_count):
        self.max_followers_count = max_followers_count

    def validate(self, site):
        followers_cnt = SiteFollow.get_site_followers_cnt(site.id)
        return followers_cnt >= self.max_followers_count


class AllValidator(IValidator):
    def __init__(self, validator_list):
        self.validator_list = validator_list

    def validate(self, site):
        for validator in self.validator_list:
            if not validator.validate(site):
                return False
        else:
            return True


class RatingValidatorFactory(object):
    def __init__(self):
        self.rule_to_validator_map = {
            'has_more_than': self._make_has_more_than_validator,
            'has_less_than': self._make_has_less_than_validator,
        }

    def make_validators(self, rule_to_parameters_map):
        return AllValidator(validator_list=list(self._make_validator_stream(rule_to_parameters_map)))
    
    def _make_validator_stream(self, rule_to_parameters_map):
        for rule, parameters in rule_to_parameters_map.items():
            yield self.rule_to_validator_map[rule](parameters)

    def _make_has_more_than_validator(self, min_followers_count):
        return HasMoreFollowersThanValidator(min_followers_count)