Skip to content

Blocks

hypha.apply.categories.blocks

ModelChooserBlock

Bases: ChoiceBlock

CategoryQuestionBlock

Bases: OptionalFormFieldBlock

category class-attribute instance-attribute 

category = ModelChooserBlock(required=True, choices=get_categories_as_choices)

multi class-attribute instance-attribute 

multi = BooleanBlock(label=gettext_lazy('Multi select'), required=False)

field_label class-attribute instance-attribute 

field_label = CharBlock(label=gettext_lazy('Label'), required=False, help_text=gettext_lazy('Leave blank to use the default Category label'))

help_text class-attribute instance-attribute 

help_text = RichTextBlock(label=gettext_lazy('Help text'), required=False, help_text=gettext_lazy('Leave blank to use the default Category help text'))

field_class class-attribute instance-attribute 

field_class = CharField

widget class-attribute instance-attribute 

widget = None

required class-attribute instance-attribute 

required = BooleanBlock(label=gettext_lazy('Required'), required=False)

Meta

template class-attribute instance-attribute 
template = 'stream_forms/render_list_field.html'
icon class-attribute instance-attribute 
icon = 'folder-open-1'

model_class 

model_class()
Source code in hypha/apply/categories/blocks.py 
45
46
47
@cached_property
def model_class(self):
    return resolve_model_string("categories.Category")

get_instance 

get_instance(id)
Source code in hypha/apply/categories/blocks.py 
49
50
def get_instance(self, id):
    return self.model_class.objects.get(id=id)

get_field_class 

get_field_class(struct_value)
Source code in hypha/apply/categories/blocks.py 
52
53
def get_field_class(self, struct_value):
    return forms.MultipleChoiceField if struct_value["multi"] else forms.ChoiceField

use_defaults_from_category 

use_defaults_from_category(kwargs, category)
Source code in hypha/apply/categories/blocks.py 
55
56
57
58
59
60
61
62
def use_defaults_from_category(self, kwargs, category):
    category_fields = {"label": "name", "help_text": "help_text"}

    for field in category_fields.keys():
        if not kwargs.get(field):
            kwargs[field] = getattr(category, category_fields[field])

    return kwargs

get_field_kwargs 

get_field_kwargs(struct_value)
Source code in hypha/apply/categories/blocks.py 
64
65
66
67
68
69
70
def get_field_kwargs(self, struct_value):
    kwargs = super().get_field_kwargs(struct_value)
    category = self.get_instance(id=struct_value["category"])
    kwargs = self.use_defaults_from_category(kwargs, category)
    choices = category.options.values_list("id", "value")
    kwargs.update({"choices": choices})
    return kwargs

get_widget 

get_widget(struct_value)
Source code in hypha/apply/categories/blocks.py 
72
73
74
75
76
77
78
79
80
81
82
83
84
def get_widget(self, struct_value):
    if struct_value["multi"]:
        category = self.get_instance(id=struct_value["category"])
        category_size = category.options.count()
        # Pick widget according to number of options to maintain good usability.
        if category_size < 32:
            return forms.CheckboxSelectMultiple
        else:
            from hypha.apply.funds.tables import MultiCheckboxesWidget

            return MultiCheckboxesWidget
    else:
        return forms.RadioSelect

prepare_data 

prepare_data(value, data, serialize)
Source code in hypha/apply/categories/blocks.py 
86
87
88
89
90
91
92
93
def prepare_data(self, value, data, serialize):
    if not data:
        return data
    if isinstance(data, str):
        data = [data]
    category = self.get_instance(id=value["category"])
    data = category.options.filter(id__in=data).values_list("value", flat=True)
    return data

render 

render(value, context)
Source code in hypha/apply/categories/blocks.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
def render(self, value, context):
    # Overwriting field_label and help_text with default for empty values
    category_fields = {"field_label": "name", "help_text": "help_text"}

    for field in category_fields.keys():
        if not value.get(field):
            category = value["category"]
            if isinstance(category, int) or isinstance(category, str):
                category = self.get_instance(id=category)
            value[field] = getattr(category, category_fields[field])
    return super().render(value, context)

get_searchable_content 

get_searchable_content(value, data)
Source code in hypha/apply/categories/blocks.py 
107
108
def get_searchable_content(self, value, data):
    return None

no_response 

no_response()
Source code in hypha/apply/categories/blocks.py 
110
111
def no_response(self):
    return "-"

get_slug 

get_slug(struct_value)
Source code in hypha/apply/stream_forms/blocks.py 
45
46
def get_slug(self, struct_value):
    return force_str(slugify(anyascii(struct_value["field_label"])))

get_field 

get_field(struct_value)
Source code in hypha/apply/stream_forms/blocks.py 
67
68
69
def get_field(self, struct_value):
    field_kwargs = self.get_field_kwargs(struct_value)
    return self.get_field_class(struct_value)(**field_kwargs)

decode 

decode(value)

Convert JSON representation into actual python objects

Source code in hypha/apply/stream_forms/blocks.py 
71
72
73
def decode(self, value):
    """Convert JSON representation into actual python objects"""
    return value

serialize 

serialize(value, context)
Source code in hypha/apply/stream_forms/blocks.py 
75
76
77
78
79
80
81
def serialize(self, value, context):
    field_kwargs = self.get_field_kwargs(value)
    return {
        "question": field_kwargs["label"],
        "answer": context.get("data"),
        "type": self.name,
    }

serialize_no_response 

serialize_no_response(value, context)
Source code in hypha/apply/stream_forms/blocks.py 
83
84
85
86
87
88
def serialize_no_response(self, value, context):
    return {
        "question": value["field_label"],
        "answer": "-",
        "type": "no_response",
    }

get_categories_as_choices 

get_categories_as_choices()
Source code in hypha/apply/categories/blocks.py 
20
21
22
def get_categories_as_choices():
    Category = resolve_model_string("categories.Category")
    return [(cat.id, cat.name) for cat in Category.objects.all()]