Struct ModelMultipleChoiceField 

pub struct ModelMultipleChoiceField<T: FormModel> {
    pub name: String,
    pub required: bool,
    pub error_messages: HashMap<String, String>,
    pub widget: Widget,
    pub help_text: String,
    pub initial: Option<Value>,
    pub queryset: Vec<T>,
    /* private fields */
}

A field for selecting multiple model instances from a queryset

This field displays model instances as choices in a multiple select widget.

Fields

name: String

The field name used as the form data key.

required: bool

Whether at least one selection is required.

error_messages: HashMap<String, String>

Custom error messages keyed by error type.

widget: Widget

The widget type used for rendering this field.

help_text: String

Help text displayed alongside the field.

initial: Option<Value>

Optional initial (default) value for the field.

queryset: Vec<T>

The list of model instances to choose from.

Implementations

impl<T: FormModel> ModelMultipleChoiceField<T>

pub fn new(name: impl Into<String>, queryset: Vec<T>) -> Self

Create a new ModelMultipleChoiceField

Examples

use reinhardt_forms::fields::ModelMultipleChoiceField;
use reinhardt_forms::FormField;
use reinhardt_forms::FormModel;
use serde_json::{json, Value};

// Define a simple Tag model
#[derive(Clone)]
struct Tag {
    id: i32,
    name: String,
}

impl FormModel for Tag {
    fn field_names() -> Vec<String> {
        vec!["id".to_string(), "name".to_string()]
    }

    fn get_field(&self, name: &str) -> Option<Value> {
        match name {
            "id" => Some(json!(self.id)),
            "name" => Some(json!(self.name)),
            _ => None,
        }
    }

    fn set_field(&mut self, _name: &str, _value: Value) -> Result<(), String> {
        Ok(())
    }

    fn save(&mut self) -> Result<(), String> {
        Ok(())
    }
}

// Create a queryset with sample tags
let tags = vec![
    Tag { id: 1, name: "rust".to_string() },
    Tag { id: 2, name: "programming".to_string() },
    Tag { id: 3, name: "web".to_string() },
];

let field = ModelMultipleChoiceField::new("tags", tags);
assert_eq!(field.name(), "tags");
assert!(FormField::required(&field));

// Test with multiple selections
let result = field.clean(Some(&json!(["1", "2"])));
assert!(result.is_ok());

pub fn required(self, required: bool) -> Self

Sets whether at least one selection is required.

pub fn help_text(self, text: impl Into<String>) -> Self

Sets the help text displayed alongside the field.

pub fn initial(self, value: Value) -> Self

Sets the initial (default) value.

pub fn error_message( self, error_type: impl Into<String>, message: impl Into<String>, ) -> Self

Overrides the error message for a specific error type.

Trait Implementations

impl<T: FormModel> FormField for ModelMultipleChoiceField<T>

fn name(&self) -> &str

Returns the field’s name used as the form data key.

fn label(&self) -> Option<&str>

Returns the human-readable label, if set.

fn widget(&self) -> &Widget

Returns the widget type used for HTML rendering.

fn required(&self) -> bool

Returns whether this field must have a non-empty value.

fn initial(&self) -> Option<&Value>

Returns the initial (default) value for this field, if any.

fn help_text(&self) -> Option<&str>

Returns optional help text displayed alongside the field.

fn clean(&self, value: Option<&Value>) -> FieldResult<Value>

Validates and cleans the submitted value, returning the cleaned result.

fn has_changed(&self, initial: Option<&Value>, data: Option<&Value>) -> bool

Check if the field value has changed from its initial value

fn error_messages(&self) -> HashMap<ErrorType, String>

Get custom error messages for this field