Frey/Web/Row.pm

package Strix::View::User;

use Data::Dump qw/dump/;
use Carp qw/carp/;

use metaclass 'Moose::Meta::Class' => (
        attribute_metaclass => 'Continuity::Meta::Attribute::FormField'
);

use Moose;

#extends 'Continuity::Widget';
extends 'Frey::Web::Button';
#with 'BonusTypes';

use Moose::Util::TypeConstraints;

enum 'Render_as' => qw( view edit none );
has _render_as => ( is => 'rw', isa => 'Render_as', required => 1, default => 'view' );

has _fey => (
        is => 'rw',
        label => 'Fey object',
        isa => 'Strix::User',
);

enum 'Layouts' => qw( div table columns );
has _layout => (
        is => 'rw',
        isa => 'Layouts',
        default => 'div',
        required => 1,
);

sub render_iterator {
        confess "BACKWARD INCOMATIBLE CHANGE: render_iterator works ONLY with 2 params!" unless $#_ == 1;
        my ($self, $iterator) = @_;
        my %attrmap = %{ $self->meta->get_attribute_map };
        my $out;
        while( my ($name, $attr) = each %attrmap ) {
                my $reader = $attr->get_read_method;
                my $val = $self->$reader || '';
                my $field_name = $self->field_name($name);
                $out .= $iterator->( $name, $field_name, $attr->label, $val ) || '';    # || '' to shut warnings
        }
        return $out;
}

sub edit_delete_buttons {
        my $self = shift;

        return unless $self->_fey;

        $self->add_button( 'Edit' => sub {
                $self->remove_button( 'Delete' );
                $self->rename_button( 'Edit' => 'Save' );
                my $out = $self->render_edit;
                my $f = $self->next($out);
                my $hash = $self->set_from_hash($f);
                warn "# Edit/Save hash = ",dump( $hash );
                $self->_fey->update( %$hash ) if $hash;
                $self->rename_button( 'Save' => 'Edit' );
                $self->delete_button;
        });
        $self->delete_button;
}

sub delete_button {
        my $self = shift;
        $self->add_button('Delete' => sub {
                $self->_fey->delete;
                $self->next( qq|<div class="notice">Deleted id @{[$self->id]}!</div>|);
                $self->_render_as( 'none' );
#               Strix::Schema->ClearObjectCaches();     # XXX important!
        });
}

sub main {
        my ( $self ) = @_;

        if ( ! $self->_fey ) {
                $self->add_button( 'Add' => sub {
                        my $f = shift;
                        my $hash = $self->set_from_hash($f);
                        delete( $hash->{id} );  # FIXME clear primary key
                        my $u = Strix::User->insert( %$hash );
                        warn "Inserted ",$u->id;
                        # XXX store object for later
                        $self->_fey( $u );
                        # put ID in widget, so that it know it's not new
                        $self->id( $u->id );
                        $self->_render_as( 'view' );
                        $self->edit_delete_buttons;
                        $self->remove_button( 'Add' );
                });
        }

        $self->edit_delete_buttons;

        warn "# ",$self->uuid, " [", $self->id ,"] _fey = ",dump( $self->_fey );

        while(1) {
        my $out;
                if ( $self->_render_as eq 'edit' ) {
                        $out .= $self->render_edit;
                } elsif ( $self->_render_as eq 'view' ) {
                        $out .= $self->render_view;
                } else {
                        warn "no renderer ",dump( $self->_render_as ), " skipping...";
                }

                warn $@ if $@;
                warn ">>> ",length($out),"\n";
                my $f = $self->next($out);
                $self->set_from_hash($f);
                $self->exec_buttons($f);
        }
};

sub render_edit {
        my $self = shift;
        warn "# render_edit ",$self->id," ",$self->uuid, " ", $self->_layout, "\n";
        my $out = $self->render_iterator( sub {
                #warn "# edit render_iterator ",dump( @_ );
                my ( $name, $field_name, $label, $val ) = @_;
                return if $name =~ /^_/;
                return qq|
                        <tr class="editform">
                        <td class="label">$label</td>
                        <td class="field">
                                <input type=text id="$field_name" name="$field_name" value="$val">
                        </td>
                        </tr>
                | if $self->_layout eq 'table';
                return qq|
                        <td class="field">
                                <input type=text id="$field_name" name="$field_name" value="$val">
                        </td>
                | if $self->_layout eq 'columns';
                return qq|
                        <div class=fieldholder>
                                <label for="$field_name">$label</label>
                                <div class=field>
                                        <input type=text id="$field_name" name="$field_name" value="$val">
                                </div>
                        </div>
                |;
        });

        return qq|<tr class="editform">$out<td>| . $self->render_buttons . qq|</td></tr>| if $self->_layout eq 'columns';

        $self->render_wrapper_class( $out, 'editform' );
}

sub render_view {
        my $self = shift;
        warn "# render_view ",$self->id," ",$self->uuid," ", $self->_layout,"\n";
        my $out = $self->render_iterator( sub {
                #warn "# view render_iterator ",dump( @_ );
                my ( $name, $field_name, $label, $val ) = @_;
                return if $name =~ /^_/;
                return qq|<tr><td>$label</td><td>$val</td></tr>| if $self->_layout eq 'table';
                return qq|<td>$val</td>| if $self->_layout eq 'columns';
                return qq|
                        <div class=fieldholder>
                                <div class=label>$label</div>
                                <div class=field>$val</div>
                                </div>
                        </div>
                |;
        });
        return qq|<tr>$out<td>| . $self->render_buttons . qq|</td></tr>| if $self->_layout eq 'columns';
        $self->render_wrapper_class( $out, 'view' );
}

sub render_wrapper_class {
        my ( $self, $out, $class ) = @_;
        if ( length($out) == 0 ) {
                carp "no output, skipping";
                return '<!-- no output -->';
        }
        $out =~ s/^\t+//mg;     # XXX compress output
        return $out . qq|<tr><td colspan=2>| . $self->render_buttons . qq|</td></tr>| if $self->_layout eq 'table';
        return qq|<div class="$class">| . $out . $self->render_buttons . qq|</div>|;
}

use Data::Dump qw/dump/;

use Strix::User;
my $m = Strix::User->meta;

foreach ( $m->get_attribute_list ) {
        my $attr = $m->get_attribute( $_ );
        warn ">> $_\n";

        # FIXME primary key would have to be read-only!

        has $_ => (
                is => $attr->_is_metadata,
                label => ucfirst($_),
                required => $attr->is_required,
        );

}

1;
1	dpavlin	63	package Strix::View::User;
2
3	dpavlin	71	use Data::Dump qw/dump/;
4	dpavlin	89	use Carp qw/carp/;
5	dpavlin	71
6	dpavlin	63	use metaclass 'Moose::Meta::Class' => (
7			attribute_metaclass => 'Continuity::Meta::Attribute::FormField'
8			);
9
10			use Moose;
11
12	dpavlin	96	#extends 'Continuity::Widget';
13			extends 'Frey::Web::Button';
14	dpavlin	63	#with 'BonusTypes';
15
16	dpavlin	97	use Moose::Util::TypeConstraints;
17	dpavlin	96
18	dpavlin	97	enum 'Render_as' => qw( view edit none );
19			has _render_as => ( is => 'rw', isa => 'Render_as', required => 1, default => 'view' );
20
21			has _fey => (
22			is => 'rw',
23			label => 'Fey object',
24			isa => 'Strix::User',
25			);
26
27			enum 'Layouts' => qw( div table columns );
28			has _layout => (
29			is => 'rw',
30			isa => 'Layouts',
31			default => 'div',
32			required => 1,
33			);
34
35	dpavlin	96	sub render_iterator {
36			confess "BACKWARD INCOMATIBLE CHANGE: render_iterator works ONLY with 2 params!" unless $#_ == 1;
37			my ($self, $iterator) = @_;
38			my %attrmap = %{ $self->meta->get_attribute_map };
39			my $out;
40			while( my ($name, $attr) = each %attrmap ) {
41			my $reader = $attr->get_read_method;
42			my $val = $self->$reader \|\| '';
43			my $field_name = $self->field_name($name);
44			$out .= $iterator->( $name, $field_name, $attr->label, $val ) \|\| ''; # \|\| '' to shut warnings
45			}
46			return $out;
47			}
48
49	dpavlin	82	sub edit_delete_buttons {
50			my $self = shift;
51
52			return unless $self->_fey;
53
54			$self->add_button( 'Edit' => sub {
55	dpavlin	91	$self->remove_button( 'Delete' );
56			$self->rename_button( 'Edit' => 'Save' );
57	dpavlin	82	my $out = $self->render_edit;
58			my $f = $self->next($out);
59			my $hash = $self->set_from_hash($f);
60	dpavlin	96	warn "# Edit/Save hash = ",dump( $hash );
61	dpavlin	92	$self->_fey->update( %$hash ) if $hash;
62	dpavlin	91	$self->rename_button( 'Save' => 'Edit' );
63			$self->delete_button;
64	dpavlin	82	});
65	dpavlin	91	$self->delete_button;
66			}
67	dpavlin	82
68	dpavlin	91	sub delete_button {
69			my $self = shift;
70	dpavlin	82	$self->add_button('Delete' => sub {
71			$self->_fey->delete;
72	dpavlin	97	$self->next( qq\|<div class="notice">Deleted id @{[$self->id]}!</div>\|);
73			$self->_render_as( 'none' );
74			# Strix::Schema->ClearObjectCaches(); # XXX important!
75	dpavlin	82	});
76			}
77
78	dpavlin	74	sub main {
79			my ( $self ) = @_;
80
81			if ( ! $self->_fey ) {
82			$self->add_button( 'Add' => sub {
83			my $f = shift;
84	dpavlin	82	my $hash = $self->set_from_hash($f);
85			delete( $hash->{id} ); # FIXME clear primary key
86			my $u = Strix::User->insert( %$hash );
87			warn "Inserted ",$u->id;
88			# XXX store object for later
89			$self->_fey( $u );
90			# put ID in widget, so that it know it's not new
91			$self->id( $u->id );
92	dpavlin	96	$self->_render_as( 'view' );
93	dpavlin	82	$self->edit_delete_buttons;
94			$self->remove_button( 'Add' );
95	dpavlin	74	});
96	dpavlin	79	}
97	dpavlin	74
98	dpavlin	82	$self->edit_delete_buttons;
99	dpavlin	79
100	dpavlin	82	warn "# ",$self->uuid, " [", $self->id ,"] _fey = ",dump( $self->_fey );
101	dpavlin	79
102	dpavlin	74	while(1) {
103	dpavlin	79	my $out;
104	dpavlin	96	if ( $self->_render_as eq 'edit' ) {
105	dpavlin	86	$out .= $self->render_edit;
106	dpavlin	96	} elsif ( $self->_render_as eq 'view' ) {
107	dpavlin	86	$out .= $self->render_view;
108	dpavlin	79	} else {
109	dpavlin	96	warn "no renderer ",dump( $self->_render_as ), " skipping...";
110	dpavlin	79	}
111
112	dpavlin	74	warn $@ if $@;
113	dpavlin	82	warn ">>> ",length($out),"\n";
114	dpavlin	71	my $f = $self->next($out);
115	dpavlin	74	$self->set_from_hash($f);
116			$self->exec_buttons($f);
117			}
118	dpavlin	71	};
119
120	dpavlin	86	sub render_edit {
121			my $self = shift;
122	dpavlin	89	warn "# render_edit ",$self->id," ",$self->uuid, " ", $self->_layout, "\n";
123			my $out = $self->render_iterator( sub {
124			#warn "# edit render_iterator ",dump( @_ );
125			my ( $name, $field_name, $label, $val ) = @_;
126			return if $name =~ /^_/;
127			return qq\|
128	dpavlin	90	<tr class="editform">
129			<td class="label">$label</td>
130			<td class="field">
131	dpavlin	89	<input type=text id="$field_name" name="$field_name" value="$val">
132			</td>
133			</tr>
134			\| if $self->_layout eq 'table';
135			return qq\|
136	dpavlin	95	<td class="field">
137			<input type=text id="$field_name" name="$field_name" value="$val">
138			</td>
139			\| if $self->_layout eq 'columns';
140			return qq\|
141	dpavlin	89	<div class=fieldholder>
142	dpavlin	90	<label for="$field_name">$label</label>
143	dpavlin	89	<div class=field>
144			<input type=text id="$field_name" name="$field_name" value="$val">
145	dpavlin	86	</div>
146	dpavlin	89	</div>
147			\|;
148			});
149	dpavlin	95
150			return qq\|<tr class="editform">$out<td>\| . $self->render_buttons . qq\|</td></tr>\| if $self->_layout eq 'columns';
151
152	dpavlin	89	$self->render_wrapper_class( $out, 'editform' );
153	dpavlin	86	}
154
155			sub render_view {
156			my $self = shift;
157	dpavlin	89	warn "# render_view ",$self->id," ",$self->uuid," ", $self->_layout,"\n";
158			my $out = $self->render_iterator( sub {
159			#warn "# view render_iterator ",dump( @_ );
160			my ( $name, $field_name, $label, $val ) = @_;
161			return if $name =~ /^_/;
162			return qq\|<tr><td>$label</td><td>$val</td></tr>\| if $self->_layout eq 'table';
163	dpavlin	95	return qq\|<td>$val</td>\| if $self->_layout eq 'columns';
164	dpavlin	89	return qq\|
165			<div class=fieldholder>
166			<div class=label>$label</div>
167			<div class=field>$val</div>
168	dpavlin	86	</div>
169	dpavlin	89	</div>
170			\|;
171			});
172	dpavlin	95	return qq\|<tr>$out<td>\| . $self->render_buttons . qq\|</td></tr>\| if $self->_layout eq 'columns';
173	dpavlin	89	$self->render_wrapper_class( $out, 'view' );
174	dpavlin	86	}
175
176	dpavlin	89	sub render_wrapper_class {
177			my ( $self, $out, $class ) = @_;
178			if ( length($out) == 0 ) {
179			carp "no output, skipping";
180			return '<!-- no output -->';
181			}
182	dpavlin	90	$out =~ s/^\t+//mg; # XXX compress output
183	dpavlin	89	return $out . qq\|<tr><td colspan=2>\| . $self->render_buttons . qq\|</td></tr>\| if $self->_layout eq 'table';
184			return qq\|<div class="$class">\| . $out . $self->render_buttons . qq\|</div>\|;
185			}
186
187	dpavlin	63	use Data::Dump qw/dump/;
188
189			use Strix::User;
190			my $m = Strix::User->meta;
191
192			foreach ( $m->get_attribute_list ) {
193	dpavlin	74	my $attr = $m->get_attribute( $_ );
194	dpavlin	63	warn ">> $_\n";
195
196	dpavlin	74	# FIXME primary key would have to be read-only!
197
198	dpavlin	63	has $_ => (
199			is => $attr->_is_metadata,
200			label => ucfirst($_),
201			required => $attr->is_required,
202			);
203
204			}
205
206			1;