File Coverage

blib/lib/Mojolicious/Plugin/FormFieldsFromJSON.pm

Criterion	Covered	Total	%
statement	451	467	96.5
branch	201	244	82.3
condition	152	253	60.0
subroutine	33	33	100.0
pod	1	1	100.0
total	838	998	83.9

package Mojolicious::Plugin::FormFieldsFromJSON;
use Mojo::Base 'Mojolicious::Plugin';

# ABSTRACT: create form fields based on a definition in a JSON file

our $VERSION = '1.01';

use Carp;
use File::Basename;
use File::Spec;
use IO::Dir;
use List::Util qw(first);

use Mojo::Asset::File;
use Mojo::Collection;
use Mojo::ByteStream;
use Mojo::File;
use Mojo::JSON qw(decode_json);

use Mojolicious ();

has dir => sub {["."]} ;

my $selected_value = Mojolicious->VERSION < 6.16 ? 'selected' : undef;
my $checked_value  = Mojolicious->VERSION < 6.16 ? 'checked'  : undef;

sub register {
    my ($self, $app, $config) = @_;

    $config //= {};

    if ( $config->{template_file} ) {
        $config->{template} = Mojo::File->new( $app->home, 'templates', $config->{template_file} )->slurp;
        $config->{template} //= $app->renderer->get_data_template( $config->{template_file} );
    }

    my %configs;
    if(ref $config->{dir} eq "ARRAY"){
        @{$self->dir} = @{$config->{dir}};
    }
    else{
        @{$self->dir} = ($config->{dir});
    }

    my %valid_types = (
        %{ $config->{types} || {} },
        text     => 1,
        checkbox => 1,
        select   => 1,
        radio    => 1,
        hidden   => 1,
        textarea => 1,
        password => 1,
    );

    my %configfiles;
    $app->helper(
        forms => sub {
            if( %configfiles ) {
                return sort keys %configfiles;
            }

            for my $dir (@{$self->dir}){
                my $dir = IO::Dir->new( $dir );

                FILE:
                while ( my $file = $dir->read ) {
                    next FILE if $file !~ m{\.json\z};

                    my $filename = basename $file;
                    $filename    =~ s{\.json\z}{};

                    $configfiles{$filename} = 1;
                }
            }

            return sort keys %configfiles;
        }
    );

    $app->helper(
        "form_fields_from_json_dir" => sub {return $self->dir}
    );

    $app->helper(
        fields => sub {
            my ($c, $file, $params) = @_;

            if ( !$configs{$file} ) {
                $self->_load_config_from_file($c, \%configs, $file);
            }

            my @fields;
            my @fields_long;
            for my $field ( @{ $configs{$file} } ) {
                my $name = $field->{label} // $field->{name} // '';
                push @fields, $name;
                push @fields_long, +{ label => $name, name => $field->{name} // '' };
            }

            if ( $params and $params->{hash} ) {
                return @fields_long;
            }

            return @fields;
        }
    );

    $app->helper(
        'validate_form_fields' => sub {
            my ($c, $file) = @_;

            return '' if !$file;

            if ( !$configs{$file} ) {
                $self->_load_config_from_file($c, \%configs, $file);
            }

            return '' if !$configs{$file};

            my $config = $configs{$file};

            my $validation = $c->validation;

            my $params_hash = $c->req->params->to_hash;
            my @param_names = keys %{ $params_hash || {} };

            my %params = map{ $_ => $c->every_param( $_ ) }@param_names;
            $validation->input( \%params );

            my %errors;

            FIELD:
            for my $field ( @{ $config } ) {
                if ( 'HASH' ne ref $field ) {
                    $app->log->error( 'Field definition must be a HASH - skipping field' );
                    next FIELD;
                }

                if ( !$field->{validation} ) {
                    next FIELD;
                }

                if ( 'HASH' ne ref $field->{validation} ) {
                    $app->log->warn( 'Validation settings must be a HASH - skipping field' );
                    next FIELD;
                }

                my $name         = $field->{name} // $field->{label} // '';
                my $global_error = 1;

                if ( $field->{validation}->{required} ) {
                    $validation->required( $name );

                    my $value  = $field->{validation}->{required};
                    if ( ref $value && 'HASH' eq ref $value ) {
                        $global_error = $value->{msg} // 1;
                    }
                }
                else {
                    $validation->optional( $name );
                }

                RULE:
                for my $rule ( sort keys %{ $field->{validation} } ) {
                    last RULE if !defined $params{$name};

                    next RULE if $rule eq 'required';

                    my $value  = $field->{validation}->{$rule};
                    my $ref    = ref $value;
                    my $method = $rule;
                    my $error  = 1;

                    my @params;

                    if ( !$ref ) {
                        @params = $value;
                    }
                    elsif ( $ref eq 'ARRAY' ) {
                        @params = @{ $value };
                    }
                    elsif ( $ref eq 'HASH' ) {
                        @params = ref $value->{args} ? @{ $value->{args} } : $value->{args};
                        $error  = $value->{msg} // 1;
                    }

                    eval{
                        $validation->check( $method, @params );
                        1;
                    } or do {
                        $app->log->error( "Validating $name with rule $method failed: $@" );
                    };

                    if ( $validation->has_error( $name ) ) {
                        $errors{$name} = $error;
                        last RULE;
                    }
                }

                if ( $validation->has_error( $name ) && !defined $errors{$name} ) {
                    $errors{$name} = $global_error;
                }
            }

            return %errors;
        }
    );

    $app->helper(
        'form_fields' => sub {
            my ($c, $file, %params) = @_;

            # get form config
            return '' if !$self->_load_config_from_file($c, \%configs, $file);
            return '' if !$configs{$file} && !ref $file;
            my $field_config = $configs{$file} || $file;

            my @fields;

            my %fields_to_show = map { $_ => 1 } @{ $params{fields} || [] };

            FIELD:
            for my $field ( @{$field_config} ) {
                next FIELD if %fields_to_show && !$fields_to_show{ $field->{name} };

                my $field_content = $self->_build_form_field($c, $field, \%params, $config, \%valid_types);

                if (length $field_content) {
                    push @fields, $field_content;
                }
            }

            return Mojo::ByteStream->new( join "\n\n", @fields );
        }
    );

    $app->helper(
        'form_field_by_name' => sub {
            my ($c, $file, $field_name, %params) = @_;

            # get form config
            return '' if !$self->_load_config_from_file($c, \%configs, $file);
            return '' if !$configs{$file} && !ref $file;
            my $field_config = $configs{$file} || $file;

            # find field config
            my @fields_filtered = grep {
                $_->{name} eq $field_name
            } @{ $field_config };

            return '' if !(scalar @fields_filtered);

            return $self->_build_form_field($c, $fields_filtered[0], \%params, $config, \%valid_types);
        }
    );
}

sub _load_config_from_file {
    my ($self, $c, $configs, $file) = @_;

    return 0 if !$file;

    if ( !$configs->{$file} && !ref $file ) {
        my $path;

        # search until first match
        my $i=0;
        do {
            my $_path= File::Spec->catfile( $self->dir->[$i], $file . '.json' );
            $path = $_path if -r $_path;
        } while ( not defined $path and ++$i <= $#{$self->dir} );

        if( not defined $path){
            $c->app->log->error( "FORMFIELDS $file: not found in directories" );
            $c->app->log->error( "  $_") for @{$self->dir};
            return 0;
        }

        eval {
            my $content     = Mojo::Asset::File->new( path => $path )->slurp;
            $configs->{$file} = decode_json $content;
        } or do {
            $c->app->log->error( "FORMFIELDS $file: $@" );
            return 0;
        };

        if ( 'ARRAY' ne ref $configs->{$file} ) {
            $c->app->log->error( 'Definition JSON must be an ARRAY' );
            return 0;
        }
    }

    return 1;
}

sub _build_form_field {
    my ($self, $c, $field, $params, $plugin_config, $valid_types) = @_;


    if ( 'HASH' ne ref $field ) {
        $c->app->log->error( 'Field definition must be an HASH - skipping field' );
        return '';
    }

    my $type      = lc $field->{type};
    my $orig_type = $type;

    if ( $plugin_config->{alias} && $plugin_config->{alias}->{$type} ) {
        $type = $plugin_config->{alias}->{$type};
    }

    if ( !$valid_types->{$type} ) {
        $c->app->log->warn( "Invalid field type $type - falling back to 'text'" );
        $type = 'text';
    }

    if ( $plugin_config->{global_attributes} && $type ne 'hidden' && 'HASH' eq ref $plugin_config->{global_attributes} ) {

        ATTRIBUTE:
        for my $attribute ( keys %{ $plugin_config->{global_attributes} } ) {
            $field->{attributes}->{$attribute} //= '';

            my $field_attr  = $field->{attributes}->{$attribute};
            my $global_attr = $plugin_config->{global_attributes}->{$attribute};

            next ATTRIBUTE if $field_attr =~ m{\Q$global_attr};

            my $space = length $field_attr ? ' ' : '';

            $field->{attributes}->{$attribute}  .= $space . $global_attr;
        }
    }

    if ( $field->{translate_sublabels} && $plugin_config->{translation_method} && !$field->{translation_method} ) {
        $field->{translation_method} = $plugin_config->{translation_method};
    }

    my $sub        = $self->can( '_' . $type );
    my $form_field = $self->$sub( $c, $field, %{ $params } );

    $form_field = Mojo::ByteStream->new( $form_field );

    my $template = $field->{template} // $plugin_config->{templates}->{$orig_type} // $plugin_config->{template};

    if ( $template && $type ne 'hidden' ) {
        my $label = $field->{label} // '';
        my $loc   = $plugin_config->{translation_method};

        if ( $plugin_config->{translate_labels} && $loc && 'CODE' eq ref $loc ) {
            $label = $loc->($c, $label);
        }

        $form_field = Mojo::ByteStream->new(
            $c->render_to_string(
                inline  => $template,
                id      => $field->{id} // $field->{name} // $field->{label} // '',
                label   => $label,
                field   => $form_field,
                message => $field->{msg}  // '',
                info    => $field->{info} // '',
            )
        );
#        $c->app->log->debug("rendered formfield: ".$form_field);
    }

    return $form_field;
}

sub _hidden {
    my ($self, $c, $field, %params) = @_;

    my $name  = $field->{name} // $field->{label} // '';

    my $from_stash_key = $params{from_stash};
    my $from_stash     = $from_stash_key ?
        $c->stash( $from_stash_key )->{$name} :
        undef;

    my $value = $params{$name}->{data} // $from_stash //
        $c->stash( $name ) // $c->param( $name ) //
        $field->{data} // '';

    my $id    = $field->{id} // $name;
    my %attrs = %{ $field->{attributes} || {} };

    return $c->hidden_field( $name, $value, id => $id, %attrs );
}

sub _text {
    my ($self, $c, $field, %params) = @_;

    my $name  = $field->{name} // $field->{label} // '';

    my $from_stash_key = $params{from_stash};
    my $from_stash     = $from_stash_key ?
        $c->stash( $from_stash_key )->{$name} :
        undef;

    my $value = $params{$name}->{data} // $from_stash //
        $c->stash( $name ) // $c->param( $name ) //
        $field->{data} // '';

    my $id    = $field->{id} // $name;
    my %attrs = %{ $field->{attributes} || {} };

    return $c->text_field( $name, $value, id => $id, %attrs );
}

sub _select {
    my ($self, $c, $field, %params) = @_;

    my $name   = $field->{name} // $field->{label} // '';

    my $from_stash_key = $params{from_stash};
    my $from_stash     = $from_stash_key ?
        $c->stash( $from_stash_key )->{$name} :
        undef;

    my $field_params = $params{$name} || {},

    my %select_params = (
       disabled => $self->_get_highlighted_values( $field, 'disabled' ),
       selected => $self->_get_highlighted_values( $field, 'selected' ),
    );

    my $stash_values = $c->every_param( $name );
    if (scalar(@{ $stash_values || [] }) == 0 && defined( $c->stash( $name ))){
        my $local_stash = $c->stash( $name );
        $stash_values = ref $local_stash ? $local_stash : [ $local_stash ];
    }

    if ( $from_stash ) {
        $stash_values = ref $from_stash ? $from_stash : [ $from_stash ];
    }

    my $reset;
    if ( @{ $stash_values || [] } ) {
        $select_params{selected} = $self->_get_highlighted_values(
            +{ selected => $stash_values },
            'selected',
        );

        $reset = 1;
    }

    for my $key ( qw/disabled selected/ ) {
        my $hashref = $self->_get_highlighted_values( $field_params, $key );
        if ( keys %{ $hashref } ) {
            $select_params{$key} = $hashref;
        }
    }

    if ( $field_params->{data} ) {
        $select_params{data} = $field_params->{data};
    }

    my @values = $self->_get_select_values( $c, $field, %select_params );
    my $id     = $field->{id} // $name;
    my %attrs  = %{ $field->{attributes} || {} };

    if ( $field->{multiple} ) {
        $attrs{multiple} = 'multiple';
        $attrs{size}     = $field->{size} || 5;
    }

    my @selected = keys %{ $select_params{selected} };
    if ( @selected ) {
        my $single = scalar @selected;
        my $param  = $single == 1 ? $selected[0] : \@selected;
        $c->param( $name, $param );
    }

    my $select_field = $c->select_field( $name, [ @values ], id => $id, %attrs );

    # reset parameters
    if ( $reset ) {
        my $single = scalar @{ $stash_values };
        my $param  = $single == 1 ? $stash_values->[0] : $stash_values;
        $c->param( $name, $param );
    }

    return $select_field;
}

sub _get_highlighted_values {
    my ($self, $field, $key) = @_;

    return +{} if !$field->{$key};

    my %highlighted;

    if ( !ref $field->{$key} ) {
        my $value = $field->{$key};
        $highlighted{$value} = 1;
    }
    elsif ( 'ARRAY' eq ref $field->{$key} ) {
        for my $value ( @{ $field->{$key} } ) {
            $highlighted{$value} = 1;
        }
    }

    return \%highlighted;
}

sub _get_select_values {
    my ($self, $c, $field, %params) = @_;

    my $data = $params{data} || $field->{data} || [];
    if ( $field->{data_cb} ) {
        my @parts   = split /::/, $field->{data_cb};
        my $subname = pop @parts;
        my $class   = join '::', @parts;
        my $sub     = $class->can( $subname );
        $data       = $sub->() if $sub;
    }

    my @values;
    if ( 'ARRAY' eq ref $data ) {
        @values = $self->_transform_array_values( $data, %params );
    }
    elsif( 'HASH' eq ref $data ) {
        @values = $self->_transform_hash_values( $c, $data, %params );
    }

    return @values;
}

sub _transform_hash_values {
    my ($self, $c, $data, %params) = @_;

    my @values;
    my $numeric = 1;
    my $counter = 0;
    my %mapping;

    KEY:
    for my $key ( keys %{ $data } ) {
        if ( ref $data->{$key} ) {
            my @group_values = $self->_get_select_values( $c, +{ data => $data->{$key} }, %params );
            $values[$counter] = Mojo::Collection->new( $key => \@group_values );
            $mapping{$key} = $counter;
        }
        else {
            my %opts;

            $opts{disabled} = 'disabled'      if $params{disabled}->{$key};
            $opts{selected} = $selected_value if $params{selected}->{$key};
            #$opts{selected} = undef if $params{selected}->{$key};

            $values[$counter] = [ $data->{$key} => $key, %opts ];
            $mapping{$key}    = $counter;
        }

        $counter++;
    }

    if ( first{ $_ =~ m{[^0-9]} }keys %mapping ) {
        $numeric = 0;
    }

    my @sorted_keys = $numeric ?
        sort { $a <=> $b }keys %mapping :
        sort { $a cmp $b }keys %mapping;

    my @indexes = @mapping{ @sorted_keys };

    my @sorted_values = @values[ @indexes ];

    return @sorted_values;
}

sub _transform_array_values {
    my ($self, $data, %params) = @_;

    my @values;
    my $numeric = 1;

    for my $value ( @{ $data } ) {
        if ( $numeric && $value =~ m{[^0-9]} ) {
            $numeric = 0;
        }

        my %opts;

        $opts{disabled} = 'disabled'      if $params{disabled}->{$value};
        $opts{selected} = $selected_value if $params{selected}->{$value};
        #$opts{selected} = undef if $params{selected}->{$value};

        push @values, [ $value => $value, %opts ];
    }

    @values = $numeric ?
        sort{ $a->[0] <=> $b->[0] }@values :
        sort{ $a->[0] cmp $b->[0] }@values;

    return @values;
}

sub _radio {
    my ($self, $c, $field, %params) = @_;

    my $name  = $field->{name} // $field->{label} // '';
    my $id    = $field->{id} // $name;
    my %attrs = %{ $field->{attributes} || {} };

    my $data   = $params{$name}->{data} // $field->{data} // [];
    my @values = ref $data ? @{ $data } : ($data);

    my $field_params = $params{$name} || {},

    my %select_params = (
       disabled => $self->_get_highlighted_values( $field, 'disabled' ),
       selected => $self->_get_highlighted_values( $field, 'selected' ),
    );

    my $stash_values = $c->every_param( $name );
    if (scalar(@{ $stash_values || [] }) == 0 && defined( $c->stash( $name ))){
        my $local_stash = $c->stash( $name );
        $stash_values = ref $local_stash ? $local_stash : [ $local_stash ];
    }
    my $reset;
    if ( @{ $stash_values || [] } ) {
        $select_params{selected} = $self->_get_highlighted_values(
            +{ selected => $stash_values },
            'selected',
        );
        $reset = 1;
    }

    for my $key ( qw/disabled selected/ ) {
        my $hashref = $self->_get_highlighted_values( $field_params, $key );
        if ( keys %{ $hashref } ) {
            $select_params{$key} = $hashref;
        }
    }

    my @selected = keys %{ $select_params{selected} };
    if ( @selected ) {
        my $single = scalar @selected;
        my $param  = $single == 1 ? $selected[0] : \@selected;
        $c->param( $name, $param );
    }

    my $radiobuttons = '';
    for my $radio_value ( @values ) {
        my %value_attributes;

        if ( $select_params{disabled}->{$radio_value} ) {
            $value_attributes{disabled} = 'disabled';
        }

        if ( $select_params{selected}->{$radio_value} ) {
            $value_attributes{checked} = $checked_value;
        }

        my $local_label = '';
        if ( $field->{show_value} ) {
            $local_label = $radio_value;
        }

        my $loc = $field->{translation_method};
        if ( length $local_label && $field->{translate_sublabels} && $loc && 'CODE' eq ref $loc ) {
            $local_label = $loc->($c, $local_label);
        }

        $local_label = " " . $local_label if length $local_label;

        $radiobuttons .= $c->radio_button(
            $name => $radio_value,
            id => $id,
            %attrs,
            %value_attributes,
        ) . "$local_label\n";

        if ( defined $field->{after_element} ) {
            $radiobuttons .= $field->{after_element};
        }
    }

    if ( $reset ) {
        my $single = scalar @{ $stash_values };
        my $param  = $single == 1 ? $stash_values->[0] : $stash_values;
        $c->param( $name, $param );
    }

    return $radiobuttons;
}

sub _checkbox {
    my ($self, $c, $field, %params) = @_;

    my $name  = $field->{name} // $field->{label} // '';
    my $id    = $field->{id} // $name;
    my %attrs = %{ $field->{attributes} || {} };

    my $data   = $params{$name}->{data} // $field->{data} // [];
    my @values = ref $data ? @{ $data } : ($data);

    my $field_params = $params{$name} || {},

    my %select_params = (
       disabled => $self->_get_highlighted_values( $field, 'disabled' ),
       selected => $self->_get_highlighted_values( $field, 'selected' ),
    );

    my $stash_values = $c->every_param( $name );
    if (scalar(@{ $stash_values || [] }) == 0 && defined( $c->stash( $name ))){
        my $local_stash = $c->stash( $name );
        $stash_values = ref $local_stash ? $local_stash : [ $local_stash ];
    }
    my $reset;
    if ( @{ $stash_values || [] } ) {
        $select_params{selected} = $self->_get_highlighted_values(
            +{ selected => $stash_values },
            'selected',
        );
        $c->param( $name, '' );
        $reset = 1;
    }

    for my $key ( qw/disabled selected/ ) {
        my $hashref = $self->_get_highlighted_values( $field_params, $key );
        if ( keys %{ $hashref } ) {
            $select_params{$key} = $hashref;
        }
    }

    my @selected = keys %{ $select_params{selected} };
    if ( @selected ) {
        my $single = scalar @selected;
        my $param  = $single == 1 ? $selected[0] : \@selected;
        $c->param( $name, $param );
    }

    my $checkboxes = '';
    for my $checkbox_value ( @values ) {
        my %value_attributes;

        if ( $select_params{disabled}->{$checkbox_value} ) {
            $value_attributes{disabled} = 'disabled';
        }

        if ( $select_params{selected}->{$checkbox_value} ) {
            $value_attributes{checked} = $checked_value;
        }

        my $local_label = '';
        if ( $field->{show_value} ) {
            $local_label = $checkbox_value;
        }

        my $loc = $field->{translation_method};
        if ( length $local_label && $field->{translate_sublabels} && $loc && 'CODE' eq ref $loc ) {
            $local_label = $loc->($c, $local_label);
        }

        $local_label = " " . $local_label if length $local_label;

        $checkboxes .= $c->check_box(
            $name => $checkbox_value,
            id => $id,
            %attrs,
            %value_attributes,
        ) . "$local_label\n";

        if ( defined $field->{after_element} ) {
            $checkboxes .= $field->{after_element};
        }
    }

    if ( $reset ) {
        my $single = scalar @{ $stash_values };
        my $param  = $single == 1 ? $stash_values->[0] : $stash_values;
        $c->param( $name, $param );
    }

    return $checkboxes;
}

sub _textarea {
    my ($self, $c, $field, %params) = @_;

    my $name  = $field->{name} // $field->{label} // '';
    my $value = $params{$name}->{data} // $c->stash( $name ) // $c->param( $name ) // $field->{data} // '';
    my $id    = $field->{id} // $name;
    my %attrs = %{ $field->{attributes} || {} };

    return $c->text_area( $name, $value, id => $id, %attrs );
}

sub _password {
    my ($self, $c, $field, %params) = @_;

    my $name  = $field->{name} // $field->{label} // '';
    my $value = $params{$name}->{data} // $c->stash( $name ) // $c->param( $name ) // $field->{data} // '';
    my $id    = $field->{id} // $name;
    my %attrs = %{ $field->{attributes} || {} };

    return $c->password_field( $name, value => $value, id => $id, %attrs );
}

1;

__END__