Changeset 86


Ignore:
Timestamp:
12/06/10 13:59:09 (13 years ago)
Author:
nanardon
Message:
  • add search over files
Location:
server/trunk/web/lib/Sophie
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed
  • server/trunk/web/lib/Sophie/Base/Result/Files.pm

    r43 r86  
    77__PACKAGE__->table('files'); 
    88__PACKAGE__->add_columns(qw/pkgid count dirname basename md5 user group linkto 
    9     mode fflags size class color vflags mtime nlink/); 
     9    mode fflags size class color vflags mtime nlink has_content/); 
    1010__PACKAGE__->set_primary_key(qw/pkgid count/); 
    1111__PACKAGE__->belongs_to(Rpms => 'Sophie::Base::Result::Rpms', 'pkgid'); 
  • server/trunk/web/lib/Sophie/Base/Result/Rpms.pm

    r40 r86  
    1111__PACKAGE__->has_many(Deps => 'Sophie::Base::Result::Deps', 'pkgid'); 
    1212__PACKAGE__->has_many(Files => 'Sophie::Base::Result::Files', 'pkgid'); 
     13__PACKAGE__->has_many(SrcFiles => 'Sophie::Base::Result::SrcFiles', 'pkgid'); 
    1314__PACKAGE__->has_many(Tags => 'Sophie::Base::Result::Tags', 'pkgid'); 
    1415 
  • server/trunk/web/lib/Sophie/Controller/Search.pm

    r83 r86  
    2727} 
    2828 
    29 sub results :Local { 
    30     my ( $self, $c ) = @_; 
    31  
    32     if ($c->req->param('page')) { 
    33         $c->req->params->{search} ||= $c->session->{search}; 
    34     } 
    35  
    36     if ($c->req->param('search')) { 
    37         $c->session->{search} = $c->req->param('search'); 
    38         $c->forward('quick', [ undef, grep { $_ } split(/\s/, $c->req->param('search')) ]); 
    39         my $pager = $c->stash->{rs}->pager; 
    40         $c->stash->{pager} = $pager; 
    41         $c->stash->{xmlrpc} = { 
    42             results => [ $c->stash->{rs}->get_column('pkgid')->all ], 
    43             pages => $pager->last_page, 
    44             current_page => $pager->current_page, 
    45             total_entries => $pager->total_entries, 
    46             entries_per_page => $pager->entries_per_page, 
    47         }; 
    48     } 
    49 } 
    50  
    51 sub search_param : Private { 
    52     my ($self, $c) = @_; 
    53     my $r = { 
    54         rows => Sophie->config()->{'max_reply'} || 20000, 
    55         order_by => [ 'name', 'evr using >>', 'issrc' ], 
    56         select => [ 'pkgid' ], 
    57     }; 
    58     if (!$c->req->xmlrpc->method) { 
    59         $r->{page} = $c->req->param('page') || 1; 
    60         $r->{rows} = $c->req->param('rows') || 15; 
    61     } 
    62     return $r; 
    63 } 
    64  
    6529sub distrib_search : Private { 
    6630    my ( $self, $c, $searchspec ) = @_; 
     
    7539    my ( $self, $c, $searchspec ) = @_; 
    7640 
     41    $searchspec ||= {}; 
    7742    my $rs = $c->stash->{rs}->search( 
    7843        {}, 
     
    9257        }; 
    9358    } 
    94     $c->stash->{xmlrpc}{results} = [ $rs->get_column('pkgid')->all ]; 
     59    $c->stash->{column} ||= 'pkgid'; 
     60    if (ref $c->stash->{column}) { 
     61        my @results; 
     62        while (my $i = $rs->next) { 
     63            push(@results, { 
     64                map { $_ => $i->get_column($_) } @{$c->stash->{column}}  
     65            }); 
     66        } 
     67        $c->stash->{xmlrpc}{results} = \@results; 
     68    } else { 
     69        $c->stash->{xmlrpc}{results} = [ 
     70            $rs->get_column($c->stash->{column})->all 
     71        ]; 
     72    } 
    9573    return $c->stash->{xmlrpc}; 
    96 } 
    97  
    98 sub bypkgid : XMLRPCPath('/search/rpm/bypkgid') { 
    99     my ( $self, $c, $searchspec, $pkgid ) = @_; 
    100  
    101     $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
    102         { 
    103             -and => [  
    104                 (exists($searchspec->{src}) 
    105                     ? { issrc => $searchspec->{src} ? 1 : 0 } 
    106                     : ()), 
    107                 { pkgid => $pkgid },  
    108                 { pkgid => 
    109                     { IN => $c->forward('distrib_search', [ $searchspec 
    110                         ])->get_column('pkgid')->as_query, },  
    111                 }, 
    112             ]      
    113         }, 
    114     ); 
    115  
    116     $c->forward('format_search', $searchspec); 
    117 } 
    118  
    119 sub bytag : XMLRPCPath('/search/rpm/bytag') { 
    120     my ( $self, $c, $searchspec, $tag, $tagvalue ) = @_; 
    121  
    122     my $tagrs = $c->model('Base')->resultset('Tags') 
    123         ->search({ tagname => lc($tag), value => $tagvalue}) 
    124         ->get_column('pkgid'); 
    125     $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
    126         { 
    127             -and => [  
    128                 (exists($searchspec->{src}) 
    129                     ? { issrc => $searchspec->{src} ? 1 : 0 } 
    130                     : ()), 
    131                 { pkgid =>  
    132                     { IN => $tagrs->as_query, }, 
    133                 }, 
    134                 { pkgid => 
    135                     { IN => $c->forward('distrib_search', [ $searchspec 
    136                         ])->get_column('pkgid')->as_query, },  
    137                 }, 
    138             ]      
    139         }, 
    140     ); 
    141     $c->forward('format_search', $searchspec); 
    142  
    143 } 
    144  
    145 sub bydep : XMLRPCPath('/search/rpm/bydep') { 
    146     my ( $self, $c, $searchspec, $deptype, $depname, $depsense, $depevr ) = @_; 
    147  
    148     my $deprs = $c->model('Base')->resultset('Deps')->search( 
    149         { 
    150             deptype => $deptype, 
    151             depname => $depname, 
    152             ($depsense 
    153                 ? (-nest => \[ 
    154                     'rpmdepmatch(flags, evr, rpmsenseflag(?), ?)', 
    155                     [ plain_text => $depsense], 
    156                     [ plain_text => $depevr ] 
    157                 ]) 
    158             : ()), 
    159         } 
    160     )->get_column('pkgid'); 
    161     $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
    162         { 
    163             -and => [  
    164                 (exists($searchspec->{src}) 
    165                     ? { issrc => $searchspec->{src} ? 1 : 0 } 
    166                     : ()), 
    167                 { pkgid =>  
    168                     { IN => $deprs->as_query, }, 
    169                 }, 
    170                 { pkgid => 
    171                     { IN => $c->forward('distrib_search', [ $searchspec 
    172                         ])->get_column('pkgid')->as_query, },  
    173                 }, 
    174             ]      
    175         }, 
    176     ); 
    177     $c->forward('format_search', $searchspec); 
    178 } 
    179  
    180 sub byfile : XMLRPCPath('/search/rpm/byfile') { 
    181     my ( $self, $c, $searchspec, $file) = @_; 
    182     my ($dirname, $basename) = $file =~ m:^(.*/)?([^/]+)$:; 
    183  
    184     my $filers = $c->model('Base')->resultset('Files') 
    185     ->search({ 
    186             ($dirname 
    187                 ? (dirname => $dirname) 
    188                 : ()), 
    189             basename => $basename, 
    190         }) 
    191     ->get_column('pkgid'); 
    192     $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
    193         { 
    194             -and => [  
    195                 (exists($searchspec->{src}) 
    196                     ? { issrc => $searchspec->{src} ? 1 : 0 } 
    197                     : ()), 
    198                 { pkgid =>  
    199                     { IN => $filers->as_query, }, 
    200                 }, 
    201                 { pkgid => 
    202                     { IN => $c->forward('distrib_search', [ $searchspec 
    203                         ])->get_column('pkgid')->as_query, },  
    204                 }, 
    205             ]      
    206         }, 
    207     ); 
    208     $c->forward('format_search', $searchspec); 
    209 } 
    210  
    211 sub fuzzy : XMLRPCPath('/search/rpm/fuzzy') { 
    212     my ($self, $c, $searchspec, $name) = @_; 
    213  
    214     my $deprs = $c->model('Base')->resultset('Deps')->search( 
    215         { deptype => 'P', depname => { '~*' => $name } } 
    216     )->get_column('pkgid'); 
    217  
    218     $c->stash->{rs} =  
    219  
    220         $c->model('Base')->resultset('Rpms')->search( 
    221         { 
    222             -and => [ 
    223                 (exists($searchspec->{src}) 
    224                     ? { issrc => $searchspec->{src} ? 1 : 0 } 
    225                     : ()), 
    226                 { -or => [ 
    227                     { name =>  
    228                         { '~*' => $name, }, 
    229                     }, 
    230 #                    { pkgid => 
    231 #                        { IN => $deprs->as_query, }, 
    232 #                    }, 
    233                      ] 
    234                 }, 
    235                 { pkgid => 
    236                     { IN => $c->forward('distrib_search', [ $searchspec 
    237                         ])->get_column('pkgid')->as_query, },  
    238                 }, 
    239             ]      
    240         }, 
    241         $c->forward('search_param'), 
    242     ); 
    243      
    244     $c->forward('format_search', $searchspec); 
    245 } 
    246  
    247 sub quick : XMLRPCPath('/search/rpm/quick') { 
    248     my ($self, $c, $searchspec, @keywords) = @_; 
    249     my $tsquery = join(' & ', map { $_ =~ s/ /\\ /g; $_ } @keywords); 
    250     $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
    251             { 
    252                 -or => [ 
    253                     { -nest => \[ 
    254                         "to_tsvector('english', description) @@ to_tsquery(?)", 
    255                         [ plain_text => $tsquery], 
    256                     ], }, 
    257                     { 
    258                     name => [ @keywords ], 
    259                     }, 
    260                 ], 
    261             (exists($searchspec->{src}) 
    262                 ? (issrc => $searchspec->{src} ? 1 : 0) 
    263                 : ()), 
    264             pkgid => 
    265             { IN => $c->forward('distrib_search', [ $searchspec 
    266                     ])->get_column('pkgid')->as_query, },  
    267  
    268  
    269         }, 
    270         { 
    271             %{$c->forward('search_param')}, 
    272         }, 
    273     ); 
    274     $c->forward('format_search', $searchspec); 
    275 } 
    276  
    277 sub description : XMLRPCPath('/search/rpm/description') { 
    278     my ($self, $c, $searchspec, @keywords) = @_; 
    279     my $tsquery = join(' & ', map { $_ =~ s/ /\\ /g; $_ } @keywords); 
    280     $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
    281         { 
    282             -nest => \[ 
    283                     "to_tsvector('english', description) @@ to_tsquery(?)", 
    284                     [ plain_text => $tsquery], 
    285                 ], 
    286                 (exists($searchspec->{src}) 
    287                     ? (issrc => $searchspec->{src} ? 1 : 0) 
    288                     : ()), 
    289                 pkgid => 
    290                     { IN => $c->forward('distrib_search', [ $searchspec 
    291                 ])->get_column('pkgid')->as_query, },  
    292                  
    293            
    294         }, 
    295         { 
    296             %{$c->forward('search_param')}, 
    297             select => [  
    298                 "ts_rank_cd(to_tsvector('english', description),to_tsquery(?)) as rank", 
    299                 'pkgid' 
    300             ], 
    301             bind => [ $tsquery ],  
    302             order_by => [ 'rank desc', 'name', 'evr using >>', 'issrc' ], 
    303         }, 
    304     ); 
    305     $c->forward('format_search', $searchspec); 
    30674} 
    30775 
     
    420188} 
    421189 
     190sub bypkgid : XMLRPCPath('/search/rpm/bypkgid') { 
     191    my ( $self, $c, $searchspec, $pkgid ) = @_; 
     192 
     193    $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
     194        { 
     195            -and => [  
     196                (exists($searchspec->{src}) 
     197                    ? { issrc => $searchspec->{src} ? 1 : 0 } 
     198                    : ()), 
     199                { pkgid => $pkgid },  
     200                { pkgid => 
     201                    { IN => $c->forward('distrib_search', [ $searchspec 
     202                        ])->get_column('pkgid')->as_query, },  
     203                }, 
     204            ]      
     205        }, 
     206    ); 
     207 
     208    $c->forward('format_search', $searchspec); 
     209} 
     210 
     211=head2 search.rpm.byname (SEARCHSPEC, NAME, [SENSE, EVR]) 
     212 
     213Search package by its NAME. SENSE and EVR are optional version filter where 
     214SENSE is dependency sign (C<E<gt>>, C<=>, ...) and EVR the search version as 
     215either C<VERSION>, C<VERSION-RELEASE> or C<EPOCH:VERSION-RELEASE>. 
     216 
     217SEARCHSPEC is a struct with search options. 
     218 
     219=cut 
     220 
     221sub byname : XMLRPCPath('/search/rpm/byname') { 
     222    my ( $self, $c, $searchspec, $name, $sense, $evr ) = @_; 
     223 
     224    $searchspec ||= {}; 
     225    $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
     226        { 
     227            -and => [  
     228                (exists($searchspec->{src}) 
     229                    ? { issrc => $searchspec->{src} ? 1 : 0 } 
     230                    : ()), 
     231                { name => $name }, 
     232                ( $evr 
     233                    ? { -nest => \[  
     234                        "rpmdepmatch(rpmsenseflag('='), evr, rpmsenseflag(?), ?)", 
     235                        [ plain_text => $sense], 
     236                        [ plain_text => $evr ], 
     237                    ] } 
     238                    : ()), 
     239                { pkgid => 
     240                    { IN => $c->forward('distrib_search', [ $searchspec 
     241                        ])->get_column('pkgid')->as_query, },  
     242                }, 
     243            ]      
     244        }, 
     245    ); 
     246    $c->forward('format_search', $searchspec); 
     247 
     248} 
     249 
     250sub bytag : XMLRPCPath('/search/rpm/bytag') { 
     251    my ( $self, $c, $searchspec, $tag, $tagvalue ) = @_; 
     252 
     253    my $tagrs = $c->model('Base')->resultset('Tags') 
     254        ->search({ tagname => lc($tag), value => $tagvalue}) 
     255        ->get_column('pkgid'); 
     256    $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
     257        { 
     258            -and => [  
     259                (exists($searchspec->{src}) 
     260                    ? { issrc => $searchspec->{src} ? 1 : 0 } 
     261                    : ()), 
     262                { pkgid =>  
     263                    { IN => $tagrs->as_query, }, 
     264                }, 
     265                { pkgid => 
     266                    { IN => $c->forward('distrib_search', [ $searchspec 
     267                        ])->get_column('pkgid')->as_query, },  
     268                }, 
     269            ]      
     270        }, 
     271    ); 
     272    $c->forward('format_search', $searchspec); 
     273 
     274} 
     275 
     276sub bydep : XMLRPCPath('/search/rpm/bydep') { 
     277    my ( $self, $c, $searchspec, $deptype, $depname, $depsense, $depevr ) = @_; 
     278 
     279    my $deprs = $c->model('Base')->resultset('Deps')->search( 
     280        { 
     281            deptype => $deptype, 
     282            depname => $depname, 
     283            ($depsense 
     284                ? (-nest => \[ 
     285                    'rpmdepmatch(flags, evr, rpmsenseflag(?), ?)', 
     286                    [ plain_text => $depsense], 
     287                    [ plain_text => $depevr ] 
     288                ]) 
     289            : ()), 
     290        } 
     291    )->get_column('pkgid'); 
     292    $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
     293        { 
     294            -and => [  
     295                (exists($searchspec->{src}) 
     296                    ? { issrc => $searchspec->{src} ? 1 : 0 } 
     297                    : ()), 
     298                { pkgid =>  
     299                    { IN => $deprs->as_query, }, 
     300                }, 
     301                { pkgid => 
     302                    { IN => $c->forward('distrib_search', [ $searchspec 
     303                        ])->get_column('pkgid')->as_query, },  
     304                }, 
     305            ]      
     306        }, 
     307    ); 
     308    $c->forward('format_search', $searchspec); 
     309} 
     310 
     311sub byfile : XMLRPCPath('/search/rpm/byfile') { 
     312    my ( $self, $c, $searchspec, $file) = @_; 
     313    my ($dirname, $basename) = $file =~ m:^(.*/)?([^/]+)$:; 
     314 
     315    my $filers = $c->model('Base')->resultset('Files') 
     316    ->search({ 
     317            ($dirname 
     318                ? (dirname => $dirname) 
     319                : ()), 
     320            basename => $basename, 
     321        }) 
     322    ->get_column('pkgid'); 
     323    $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
     324        { 
     325            -and => [  
     326                (exists($searchspec->{src}) 
     327                    ? { issrc => $searchspec->{src} ? 1 : 0 } 
     328                    : ()), 
     329                { pkgid =>  
     330                    { IN => $filers->as_query, }, 
     331                }, 
     332                { pkgid => 
     333                    { IN => $c->forward('distrib_search', [ $searchspec 
     334                        ])->get_column('pkgid')->as_query, },  
     335                }, 
     336            ]      
     337        }, 
     338    ); 
     339    $c->forward('format_search', $searchspec); 
     340} 
     341 
     342sub fuzzy : XMLRPCPath('/search/rpm/fuzzy') { 
     343    my ($self, $c, $searchspec, $name) = @_; 
     344 
     345    my $deprs = $c->model('Base')->resultset('Deps')->search( 
     346        { deptype => 'P', depname => { '~*' => $name } } 
     347    )->get_column('pkgid'); 
     348 
     349    $c->stash->{rs} =  
     350 
     351        $c->model('Base')->resultset('Rpms')->search( 
     352        { 
     353            -and => [ 
     354                (exists($searchspec->{src}) 
     355                    ? { issrc => $searchspec->{src} ? 1 : 0 } 
     356                    : ()), 
     357                { -or => [ 
     358                    { name =>  
     359                        { '~*' => $name, }, 
     360                    }, 
     361#                    { pkgid => 
     362#                        { IN => $deprs->as_query, }, 
     363#                    }, 
     364                     ] 
     365                }, 
     366                { pkgid => 
     367                    { IN => $c->forward('distrib_search', [ $searchspec 
     368                        ])->get_column('pkgid')->as_query, },  
     369                }, 
     370            ]      
     371        }, 
     372        $c->forward('search_param'), 
     373    ); 
     374     
     375    $c->forward('format_search', $searchspec); 
     376} 
     377 
     378sub quick : XMLRPCPath('/search/rpm/quick') { 
     379    my ($self, $c, $searchspec, @keywords) = @_; 
     380    my $tsquery = join(' & ', map { $_ =~ s/ /\\ /g; $_ } @keywords); 
     381    $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
     382            { 
     383                -or => [ 
     384                    { -nest => \[ 
     385                        "to_tsvector('english', description) @@ to_tsquery(?)", 
     386                        [ plain_text => $tsquery], 
     387                    ], }, 
     388                    { 
     389                    name => [ @keywords ], 
     390                    }, 
     391                ], 
     392            (exists($searchspec->{src}) 
     393                ? (issrc => $searchspec->{src} ? 1 : 0) 
     394                : ()), 
     395            pkgid => 
     396            { IN => $c->forward('distrib_search', [ $searchspec 
     397                    ])->get_column('pkgid')->as_query, },  
     398 
     399 
     400        }, 
     401        { 
     402            %{$c->forward('search_param')}, 
     403        }, 
     404    ); 
     405    $c->forward('format_search', $searchspec); 
     406} 
     407 
     408sub description : XMLRPCPath('/search/rpm/description') { 
     409    my ($self, $c, $searchspec, @keywords) = @_; 
     410    my $tsquery = join(' & ', map { $_ =~ s/ /\\ /g; $_ } @keywords); 
     411    $c->stash->{rs} = $c->model('Base')->resultset('Rpms')->search( 
     412        { 
     413            -nest => \[ 
     414                    "to_tsvector('english', description) @@ to_tsquery(?)", 
     415                    [ plain_text => $tsquery], 
     416                ], 
     417                (exists($searchspec->{src}) 
     418                    ? (issrc => $searchspec->{src} ? 1 : 0) 
     419                    : ()), 
     420                pkgid => 
     421                    { IN => $c->forward('distrib_search', [ $searchspec 
     422                ])->get_column('pkgid')->as_query, },  
     423                 
     424           
     425        }, 
     426        { 
     427            %{$c->forward('search_param')}, 
     428            select => [  
     429                "ts_rank_cd(to_tsvector('english', description),to_tsquery(?)) as rank", 
     430                'pkgid' 
     431            ], 
     432            bind => [ $tsquery ],  
     433            order_by => [ 'rank desc', 'name', 'evr using >>', 'issrc' ], 
     434        }, 
     435    ); 
     436    $c->forward('format_search', $searchspec); 
     437} 
     438 
     439sub file_search : XMLRPCPath('/search/file/byname') { 
     440    my ( $self, $c, $searchspec, $file) = @_; 
     441    my ($dirname, $basename) = $file =~ m:^(.*/)?([^/]+)$:; 
     442    $searchspec ||= {}; 
     443 
     444    my $filers = $c->stash->{rs} = $c->model('Base::Files') 
     445    ->search( 
     446        { 
     447            -and => [ 
     448                ($dirname 
     449                    ? (dirname => $dirname) 
     450                    : ()), 
     451                basename => $basename, 
     452                pkgid => { 
     453                    IN => $c->forward('distrib_search', 
     454                        [ $searchspec ])->get_column('pkgid')->as_query, 
     455                }, 
     456            ], 
     457        } 
     458    ); 
     459     
     460    $c->stash->{column} = \qw(basename); 
     461     
     462    $c->forward('format_search', $searchspec); 
     463} 
     464 
    422465=head1 AUTHOR 
    423466 
Note: See TracChangeset for help on using the changeset viewer.