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';
#with 'BonusTypes';

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 {
                print STDERR "delete ID @{[$self->id]}!\n";
                $self->_fey->delete;
                $self->next("Deleted id @{[$self->id]}!");
                $self->render_as( 'deleted' );
                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|
                        <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>
                |;
        });
        $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|
                        <div class=fieldholder>
                                <div class=label>$label</div>
                                <div class=field>$val</div>
                                </div>
                        </div>
                |;
        });
        $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,
        );

}

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

use Moose::Util::TypeConstraints;

enum 'Layouts' => qw( div table );

has _layout => (
        is => 'rw',
        isa => 'Layouts',
        default => 'div',
);

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