Frey/Web/Item.pm

package Frey::Web::Row;

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

use Moose;

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 => 'Object',        # FIXME Strix::User?
#       required => 1,          # XXX if we require it we can't have Add form
);

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

has 'display_columns' => (
        is => 'rw',
        isa => 'ArrayRef[Str]',
        lazy_build => 1,
);

sub id {
        my $self = shift;
        carp "LEGACY: called ->id";
        $self->fey->id if $self->fey;
}

sub set_from_hash {
        my ($self, $f) = @_;
        my $attrmap = $self->fey->meta->get_attribute_map if $self->fey;
        my $hash;
        foreach my $name ( @{ $self->display_columns } ) {
                my $field_name = $self->field_name($name);
                if(defined $f->{$field_name}) {
                        $hash->{ $name } = $f->{$field_name};

                        if ( defined $attrmap->{$name} ) {
                                my $writer = $attrmap->{$name}->get_write_method;
                                $self->fey->$writer($f->{$field_name});
                        } else {
                                warn "can't store value back into fey->$name";
                        }
                }
        }
        warn "# set_from_hash ", $self->uuid," produced hash = ",dump( $hash ) if $hash;
        return $hash;
}

sub render_iterator {
        confess "BACKWARD INCOMATIBLE CHANGE: render_iterator works ONLY with 2 params!" unless $#_ == 1;
        my ($self, $iterator) = @_;
        my $out;
#       my %attrmap = %{ $self->meta->get_attribute_map };
#       while( my ($name, $attr) = each %attrmap ) {
#               my $reader = $attr->get_read_method;
#               my $val = $self->$reader || '';
        foreach my $name ( @{ $self->display_columns } ) {
                my $field_name = $self->field_name($name);
                my $val;
                $val = $self->fey->$name if $self->fey && $self->fey->can($name);
                $out .= $iterator->( $name, $field_name, ucfirst($name), $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);
                        warn "## Add hash ", $self->uuid, " => ",dump( $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 Strix::User;

sub _build_display_columns {
        my $self = shift;

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

        my @cols;

        foreach ( $m->get_attribute_list ) {
                my $attr = $m->get_attribute( $_ );
                warn ">> $_\n";
                # FIXME primary key would have to be read-only!
                push @cols, $_;
        }

        warn "## display_columns ",dump( @cols );

        return \@cols;
}

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