view release on metacpan or  search on metacpan

lib/Beagle/Web/Router.pm  view on Meta::CPAN

get '/admin/entries' => sub {
    render 'admin/entries',
      entries => handle()->entries,
      title   => 'admin',
      page_limit => 20,
      prefix  => prefix() || '../';
};

get '/admin/entry/:type/new' => sub {
    my %vars  = @_;
    my $type  = lc $vars{'type'};
    my $class = entry_type_info->{ lc $type }{class};
    if ($class) {
        my $entry = $class->new( id => 'new' );

        return render 'admin/entry',
          entry => $entry,
          form  => Beagle::Web::Form->new(
            field_list => scalar Beagle::Web->field_list($entry) ),
          title  => 'create ' . A($type),
          prefix => prefix() || '../../../';
    }
};

get '/admin/entry/{id:\w{32}}' => sub {
    my %vars = @_;
    my ($id) = $vars{id};

    return redirect '/admin/entries'
      unless handle()->map->{$id};
    render 'admin/entry',
      message => $vars{'message'},
      entry   => handle()->map->{$id},
      form    => Beagle::Web::Form->new(
        field_list => scalar Beagle::Web->field_list( handle()->map->{$id} ) ),
      title  => "update $id",
      prefix => prefix() || '../../';
};

post '/admin/entry/:type/new' => sub {
    my %vars = @_;
    my $type = $vars{'type'};
    my $class = entry_type_info->{ lc $type }{class};
    if ($class) {
        my $entry = $class->new( timezone => handle()->info->timezone );
        if ( $entry->can('author') && !$entry->author ) {
            $entry->author( current_user() );
        }

        if ( $type eq 'comment' && !request()->param('format') ) {

            # make comment's format be plain by default if from web ui
            $entry->format('plain');
        }

        if ( process_fields( $entry, request()->parameters->mixed ) ) {
            my ($created) =
              handle()->create_entry( $entry, message => request()->param('message') );

            if ($created) {
                add_attachments( $entry, request()->upload('attachments') );
                if ( request()->header('Accept') =~ /json/ ) {
                    my $ret = {
                        status    => 'created',
                        parent_id => $entry->parent_id,
                        content   => render( 'entry_comment', entry => $entry ),
                    };
                    status(201);
                    content_type('application/json');
                    return to_json($ret);
                }

                if ( $type eq 'comment' ) {
                    return
                        redirect '/entry/'
                      . $entry->parent_id
                      . '?message=created' . '#'
                      . $entry->id;
                }
                else {
                    return
                        redirect '/entry/'
                      . $entry->id
                      . '?message=created';
                }
            }
            else {
                if ( request()->header('Accept') =~ /json/ ) {
                    my $ret = {
                        status  => 'error',
                        message => 'failed to create',
                    };
                    content_type('application/json');
                    return to_json($ret);
                }
            }
        }
        else {
            return render "admin/entry/$type/new",
              entry => $entry,
              form  => Beagle::Web::Form->new(
                field_list => scalar Beagle::Web->field_list($entry) ),
              message => 'invalid';
        }
    }

    if ( request()->header('Accept') =~ /json/ ) {
        my $ret = {
            status  => 'error',
            content => "invalid type: $type",
        };
        content_type('application/json');
        return to_json($ret);
    }
    else {
        redirect '/admin/entries';
    }
};

post '/admin/entry/{id:\w{32}}' => sub {
    my %vars = @_;
    my ($id) = $vars{id};

    if ( my $entry = handle()->map->{$id} ) {

        if ( process_fields( $entry, request()->parameters->mixed ) ) {

            handle()->update_entry( $entry, message => request()->param('message') );

            my $del = $vars{'delete-attachments'};
            delete_attachments( $entry, ref $del ? @$del : $del );

            add_attachments( $entry, request()->upload('attachments') );

            render 'admin/entry',
              entry => $entry,
              form  => Beagle::Web::Form->new(
                field_list => scalar Beagle::Web->field_list($entry) ),
              message => 'updated',
              prefix  => prefix() || '../../';
        }
        else {
            render 'admin/entry',
              entry => $entry,
              form  => Beagle::Web::Form->new(
                field_list => scalar Beagle::Web->field_list($entry) ),
              message => 'invalid',
              prefix  => prefix() || '../../';
        }
    }
    else {
        redirect '/admin/entries';
    }
};

post '/admin/entry/delete' => sub {
    my $id = request()->param('id');

    if ( request()->header('Accept') =~ /json/ ) {
        content_type('application/json');
    }

    if ( my $entry = handle()->map->{$id} ) {
        handle()->delete_entry($entry);
        my $ret = { status => 'deleted' };
        $ret->{redraw_menu} = 1 unless $entry->type eq 'comment';
        return to_json($ret);
    }
    else {
        return to_json {
            status  => 'error',
            message => 'not exist'
        };
    }

    redirect '/admin/entries';
};

any '/admin/info' => sub {
    my $entry = handle()->info;
    redirect '/admin/entry/' . $entry->id;
};

get '/favicon.ico' => sub {
    if (   handle()->info->avatar
        && handle()->info->avatar ne '/favicon.ico' )
    {
        redirect handle()->info->avatar;
    }
    else {
        redirect '/system/images/beagle.png';
    }
};