lib/Slists/Controller/Lists.pm

   1 package Slists::Controller::Lists;
   2 use Moose;
   3 use namespace::autoclean;
   4 use Data::Dumper; #XXX
   5 use Slists::Form::List;
   6
   7 BEGIN { extends 'Catalyst::Controller'; }
   8
   9 =head1 NAME
  10
  11 Slists::Controller::Lists - Catalyst Controller
  12
  13 =head1 DESCRIPTION
  14
  15 Catalyst Controller.
  16
  17 =head1 METHODS
  18
  19 =cut
  20
  21 =head2 index
  22
  23 =cut
  24
  25 sub index :Path :Args(0) {
  26     my ( $self, $c ) = @_;
  27
  28     $c->response->body('Matched Slists::Controller::Lists in Lists.');
  29 }
  30
  31
  32
  33 =head2 base
  34
  35 Can place common logic to start chained dispatch here
  36
  37 =cut
  38
  39 sub base :Chained('/') :PathPart('lists') :CaptureArgs(0) {
  40     my ($self, $c) = @_;
  41
  42     # Store the ResultSet in stash so it's available for other methods
  43     $c->stash(resultset => $c->model('DB::List'));
  44
  45     # Print a message to the debug log
  46     $c->log->debug('*** INSIDE BASE METHOD ***');
  47
  48     # Load status messages
  49     $c->load_status_msgs;
  50 }
  51
  52 =head2 list
  53
  54 Fetch all lists objects [for this user] and pass to lists/list.tt2 in stash to be displayed
  55
  56 =cut
  57
  58 sub list :Chained('base') :PathParth('list') :Args(0) {
  59     # Retrieve the usual Perl OO '$self' for this object. $c is the Catalyst
  60     # 'Context' that's used to 'glue together' the various components
  61     # that make up the application
  62     my ($self, $c) = @_;
  63
  64     # retrieve all lists for this user
  65     $c->stash(lists => [$c->model('DB::List')->search({
  66         user_id => $c->user->id,
  67       })->all
  68     ]);
  69
  70     # Set the TT template to use.  You will almost always want to do this
  71     # in your action methods (action methods respond to user input in
  72     # your controllers).
  73     $c->stash(template => 'lists/list.tt2');
  74 }
  75
  76 =head2 object
  77
  78 Fetch the specified list object based on the list ID and store
  79 it in the stash
  80
  81 =cut
  82
  83 sub object :Chained('base') :PathPart('id') :CaptureArgs(1) {
  84     # $id = primary key of book to delete
  85     my ($self, $c, $id) = @_;
  86
  87     # Find the book object and store it in the stash
  88     $c->stash(object => $c->stash->{resultset}->find($id));
  89
  90     # Make sure the lookup was successful.  You would probably
  91     # want to do something like this in a real app:
  92     #   $c->detach('/error_404') if !$c->stash->{object};
  93     $c->log->debug("Lists::object - List id is $id");
  94     die "List $id not found!" if !$c->stash->{object};
  95
  96     # Print a message to the debug log
  97     $c->log->debug("*** INSIDE OBJECT METHOD for obj id=$id ***");
  98 }
  99
 100 =head2 delete
 101
 102 Delete a list
 103
 104 =cut
 105
 106 sub delete :Chained('object') :PathPart('delete') :Args(0) {
 107     my ($self, $c) = @_;
 108
 109     # Saved the PK id for status_msg below
 110     my $id = $c->stash->{object}->id;
 111
 112     # Use the list object saved by 'object' and delete it [along
 113     # with related 'list_author' entries]
 114     $c->stash->{object}->delete;
 115
 116     # Redirect the user back to the list page
 117     $c->response->redirect($c->uri_for($self->action_for('list'),
 118         {mid => $c->set_status_msg("Deleted list $id")}));
 119 }
 120
 121 =head2 edit
 122
 123 This one is very similar to list, but it lists list items, not lists.
 124
 125 =cut
 126
 127 sub view :Chained('object') :PathPart('view') :Args(0) {
 128     my ($self, $c) = @_;
 129     # get list id
 130     my $id = $c->stash->{object}->id;
 131
 132     # get list item info from database
 133     $c->stash(list_items => [$c->model('DB::ListItem')->search(
 134      { 'list_id' => $id },
 135      {
 136        join => {'products' => 'products' },
 137        '+select' => [ 'products.id', 'products.name', 'products.weight', 'products.cost' ],
 138        '+as' => [ 'pid', 'name', 'weight', 'cost' ],
 139      },
 140      { 'pid' => 'product_id' },
 141      )->all
 142     ]);
 143     $c->stash(list_id => $id);
 144
 145     # use template
 146     $c->stash(template => 'lists/view.tt2');
 147 }
 148
 149
 150 =head2 create
 151
 152 Rename an existing list with FormHandler
 153
 154 =cut
 155
 156 sub rename : Chained('object') PathPart('rename') Args(0) {
 157     my ( $self, $c ) = @_;
 158
 159     # $c->set_status_msg("List renamed");
 160     # did not work
 161     $c->stash( my_status_msg => "List renamed" );
 162
 163     return $self->form($c, $c->stash->{object});
 164 }
 165
 166 =head2 create
 167
 168 Use HTML::FormHandler to create a new list
 169
 170 =cut
 171
 172 sub create : Chained('base') : PathPart('create') Args(0) {
 173     my ($self, $c ) = @_;
 174     my $list = $c->model('DB::List')->new_result({ user_id => $c->user->id });
 175     $c->stash( my_status_msg => "List created" );
 176     return $self->form($c, $list);
 177 }
 178
 179 =head2 form
 180
 181 Process the FormHandler list form
 182 This is a separate function, because it's used by both /create and /edit.
 183
 184 =cut
 185
 186 sub form{
 187     my ( $self, $c, $list ) = @_;
 188     my $form = Slists::Form::List->new;
 189     # Set the template
 190     $c->stash( template => 'lists/form.tt2', form => $form );
 191     $form->process(
 192       item => $list,
 193       params => $c->req->params,
 194     );
 195     return unless $form->validated;
 196     # Set a status message for the user & return to books list
 197     return $c->response->redirect($c->uri_for($self->action_for('list'),
 198         {mid => $c->set_status_msg($c->stash->{my_status_msg})}));
 199 }
 200
 201 =head1 AUTHOR
 202
 203 user,,,,
 204
 205 =head1 LICENSE
 206
 207 This library is free software. You can redistribute it and/or modify
 208 it under the same terms as Perl itself.
 209
 210 =cut
 211
 212 __PACKAGE__->meta->make_immutable;
 213
 214 1;