view release on metacpan or  search on metacpan

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

    return Beagle::I18N->get_handle(@lang);
}

sub change_handle {
    shift @_ if @_ && $_[0] eq 'Beagle::Web';
    my %vars = @_;
    if ( $vars{handle} ) {
        $bh        = $vars{handle};
        $name      = $bh->name;
        $bh{$name} = $bh;
    }
    elsif ( $vars{name} ) {
        my $n = $vars{name};
        $bh   = $bh{$n};
        $name = $n;
    }
    else {
        return;
    }

    return $Beagle::Util::ROOT = $bh->root;
}

sub process_fields {
    shift @_ if @_ && $_[0] eq 'Beagle::Web';
    my ( $entry, $params ) = @_;

    my %fields = Beagle::Web->field_list($entry);
    for my $field ( keys %$params ) {
        next unless $entry->can($field) && $fields{$field};
        my $new = $params->{$field};
        if ( $field eq 'body' ) {
            $new = $entry->parse_body($new);
        }

        my $old = $entry->serialize_field($field);

        if ( "$new" ne "$old" ) {
            $entry->$field( $entry->parse_field( $field, $new ) );
        }
    }
    return 1;
}

sub delete_attachments {
    shift @_ if @_ && $_[0] eq 'Beagle::Web';
    my ( $entry, @names ) = @_;
    for my $name (@names) {
        next unless defined $name;
        my $att = Beagle::Model::Attachment->new(
            name      => $name,
            parent_id => $entry->id,
        );
        $bh->delete_attachment($att);
    }
}

sub add_attachments {
    shift @_ if @_ && $_[0] eq 'Beagle::Web';
    my ( $entry, @attachments ) = @_;
    for my $upload (@attachments) {
        next unless $upload;

        my $basename = decode_utf8 $upload->filename;
        $basename =~ s!\\!/!g;
        $basename =~ s!.*/!!;

        my $att = Beagle::Model::Attachment->new(
            name         => $basename,
            content_file => $upload->tempname,
            parent_id    => $entry->id,
        );
        $bh->create_attachment( $att,
                message => 'added attachment '
              . $basename
              . ' for entry '
              . $entry->id );
    }
}

sub handle  { $bh }
sub request { $req }

sub set_prefix {
    shift @_ if @_ && $_[0] eq 'Beagle::Web';
    $prefix = shift;
}

sub set_static {
    shift @_ if @_ && $_[0] eq 'Beagle::Web';
    $static = shift;
}

sub default_options {
    my $bh = handle();

    return (
        $bh->list,
        handle      => $bh,
        name        => $name,
        admin       => web_admin(),
        feed        => Beagle::Web->feed($bh),
        archives    => Beagle::Web->archives($bh),
        tags        => Beagle::Web->tags($bh),
        entry_types => entry_types(),
        prefix      => $prefix,
        static      => $static,
        css =>
          [ @{ $css{base} || [] }, @{ $css{ $bh->info->layout } || [] } ],
        js => [ @{ $js{base} || [] }, @{ $js{ $bh->info->layout } || [] } ],
        ( $req->env->{'BEAGLE_NAME'} || $req->header('X-Beagle-Name') )
        ? ()
        : ( names => $names ),
        current_user => current_user(),
    );
}

sub _fill_page_info {
    my $vars  = shift;
    my $field = shift;
    my $limit =
         $vars->{page_limit}
      || $ENV{BEAGLE_PAGE_LIMIT}
      || $bh->info->page_limit
      || 10;
    if ( $vars->{$field} ) {
        $vars->{page} = request()->param('p') || 1;
        my $page =
          Data::Page->new( scalar @{ $vars->{$field} }, $limit, $vars->{page} );
        $vars->{$field} = [ $page->splice( $vars->{$field} ) ];