WebPAC/Output/Webpacus.pm

package WebPAC::Output::Webpacus;

use warnings;
use strict;

use base qw/WebPAC::Common WebPAC::Output Class::Accessor/;
__PACKAGE__->mk_accessors(qw(
        path
        database
        input
));

use File::Path;
use Data::Dump qw/dump/;
use WebPAC::Common qw/force_array/;
use Carp qw/confess/;
use Cwd;
use File::Slurp;

use Jifty;

=head1 NAME

WebPAC::Output::Webpacus - integrate WebPAC front-end with Jifty back-end

=cut

our $VERSION = '0.03';

=head1 SYNOPSIS

Does black magic to sync data between WebPAC and Webpacus, web front-end
implement in Jifty

=head1 FUNCTIONS

=head2 new

 my $output = new WebPAC::Output::Webpacus({
        path => '/path/to/Webpacus',
        database => 'demo',
 });

=head2 init

 $output->init;

=cut

sub init {
        my $self = shift;

        my $log = $self->_get_logger;

        foreach my $p (qw/path database/) {
                $log->logdie("need $p") unless ($self->$p);
        }

        my $path = $self->path;

        $log->logdie("Webpacus path $path not found: $!") unless -d $path;

        my $config_path = "$path/etc/config.yml";

        $log->logdie("expected Webpacus config at $config_path: $!") unless -e $config_path;

        $self->{fields} = {};

}


=head2 add

Adds one entry

  $est->add( 42, $ds );

=cut

sub add {
        my $self = shift;

        my ( $id, $ds ) = @_;

        my $log = $self->_get_logger;
        $log->logdie("need id") unless defined $id;
        $log->logdie("need ds") unless $ds;

        $log->debug("id: $id ds = ",sub { dump($ds) });

        my $stat;

        foreach my $type ( $self->consume_outputs ) {

                my $hash = $self->ds_to_hash( $ds, $type ) || next;

                $log->debug("$type has following data: ", sub { dump( $hash ) });

                foreach my $f ( keys %$hash ) {
                        $self->{fields}->{$type}->{$f}++;
                        $stat->{$type}->{$f}++;
                }
        }

        $log->debug("this record added following fields: ", sub { dump( $stat ) });

        return 1;
}

=head2 finish

Close index

 my $affected = $index->finish;

Returns of records saved in total

=cut

sub finish {
        my $self = shift;

        my $log = $self->_get_logger();

        my $fields = $self->{fields} || confess "no fields?";

        $log->debug("fields = ", sub { dump $fields });

        $log->info("init Jifty");
        my $path = $self->path || confess "no path?";
        my $webpac_dir = getcwd();
        chdir $path || $log->logdie("can't chdir($path) $!");
        Jifty->new();

        my $affected = 0;

        foreach my $type ( $self->consume_outputs ) {
                next unless defined $fields->{$type};
                $affected += $self->_sync_field(
                        $self->database, $type, $fields->{$type}
                );
        }


        my $glue_path = "$path/lib/Webpacus/Webpac.pm";

        $log->debug("creating clue class Webpacus::Webpac at $glue_path");

        my $glue = <<"_END_OF_GLUE_";
package Webpacus::Webpac;

=head1 NAME

Webpacus::Webpac - configuration exported from WebPAC

=cut

use strict;
use warnings;

sub index_path { '/data/webpac2/var/kinosearch/' };

1;
_END_OF_GLUE_

        $log->debug("glue source:\n$glue");

        write_file( $glue_path, $glue ) || $log->logdie("can't create $glue_path: $!");

        return $affected;
};

sub _sync_field {
        my $self = shift;

        my ( $database, $type, $field_hash ) = @_;

        my $path = $self->path || confess "no path?";

        my $log = $self->_get_logger();

        my $model = 'Webpacus::Model::' . ucfirst($type);
        $log->info("sync $model");

        $log->debug("field_hash = ",sub { dump($field_hash) });

        my @field_names = keys %$field_hash;

        if ( ! @field_names ) {
                $log->warn("normalization rules don't produce any data for search!");
                return;
        }

        $log->info("syncing $database $type fields: ", join(", ", @field_names));

        my $system_user = Webpacus::CurrentUser->superuser;
        my $o = $model->new(current_user => $system_user);

        my ( $count, $new, $updated ) = ( 0, 0, 0 );

        foreach my $field ( @field_names ) {
                my $items = $field_hash->{$field} || confess "no field?";

                my ( $id, $msg ) = $o->load_by_cols(
                        name => $field,
                        from_database => $database,
                );

                if ( $id ) {
                        $o->set_items( $items );
                        $log->debug("updated $database $type field: $field [$items] ID: $id $msg");
                        $updated++;
                } else {
                        $log->debug("adding $database $type field: $field [$items] $msg");
                        $o->create(
                                name => $field,
                                from_database => $database,
                                items => $items,
                        );
                        $new++;
                }

                $count++;
        }

        $log->info("synced $count fields (",join(", ", @field_names),") from $database with Webpacus ($new new/$updated updated) at $path");

        return $count;

}

=head2 consume_outputs

Returns array with names of supported output types for this module

=cut

sub consume_outputs {
        return qw/search sorted/;
}

=head1 AUTHOR

Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>

=head1 COPYRIGHT & LICENSE

Copyright 2007 Dobrica Pavlinusic, All Rights Reserved.

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

=cut

1;
1	dpavlin	932	package WebPAC::Output::Webpacus;
2
3			use warnings;
4			use strict;
5
6			use base qw/WebPAC::Common WebPAC::Output Class::Accessor/;
7			__PACKAGE__->mk_accessors(qw(
8			path
9			database
10	dpavlin	936	input
11	dpavlin	932	));
12
13			use File::Path;
14			use Data::Dump qw/dump/;
15			use WebPAC::Common qw/force_array/;
16			use Carp qw/confess/;
17			use Cwd;
18	dpavlin	933	use File::Slurp;
19	dpavlin	932
20			use Jifty;
21
22			=head1 NAME
23
24			WebPAC::Output::Webpacus - integrate WebPAC front-end with Jifty back-end
25
26			=cut
27
28	dpavlin	997	our $VERSION = '0.03';
29	dpavlin	932
30			=head1 SYNOPSIS
31
32			Does black magic to sync data between WebPAC and Webpacus, web front-end
33			implement in Jifty
34
35			=head1 FUNCTIONS
36
37			=head2 new
38
39			my $output = new WebPAC::Output::Webpacus({
40			path => '/path/to/Webpacus',
41			database => 'demo',
42			});
43
44			=head2 init
45
46			$output->init;
47
48			=cut
49
50			sub init {
51			my $self = shift;
52
53			my $log = $self->_get_logger;
54
55			foreach my $p (qw/path database/) {
56			$log->logdie("need $p") unless ($self->$p);
57			}
58
59			my $path = $self->path;
60
61			$log->logdie("Webpacus path $path not found: $!") unless -d $path;
62
63			my $config_path = "$path/etc/config.yml";
64
65			$log->logdie("expected Webpacus config at $config_path: $!") unless -e $config_path;
66
67			$self->{fields} = {};
68
69			}
70
71
72			=head2 add
73
74			Adds one entry
75
76			$est->add( 42, $ds );
77
78			=cut
79
80			sub add {
81			my $self = shift;
82
83			my ( $id, $ds ) = @_;
84
85			my $log = $self->_get_logger;
86			$log->logdie("need id") unless defined $id;
87			$log->logdie("need ds") unless $ds;
88
89			$log->debug("id: $id ds = ",sub { dump($ds) });
90
91	dpavlin	993	my $stat;
92	dpavlin	932
93	dpavlin	993	foreach my $type ( $self->consume_outputs ) {
94
95			my $hash = $self->ds_to_hash( $ds, $type ) \|\| next;
96
97			$log->debug("$type has following data: ", sub { dump( $hash ) });
98
99			foreach my $f ( keys %$hash ) {
100			$self->{fields}->{$type}->{$f}++;
101			$stat->{$type}->{$f}++;
102			}
103	dpavlin	932	}
104
105	dpavlin	993	$log->debug("this record added following fields: ", sub { dump( $stat ) });
106
107	dpavlin	932	return 1;
108			}
109
110			=head2 finish
111
112			Close index
113
114	dpavlin	993	my $affected = $index->finish;
115	dpavlin	932
116	dpavlin	993	Returns of records saved in total
117
118	dpavlin	932	=cut
119
120			sub finish {
121			my $self = shift;
122
123			my $log = $self->_get_logger();
124
125			my $fields = $self->{fields} \|\| confess "no fields?";
126	dpavlin	993
127			$log->debug("fields = ", sub { dump $fields });
128
129	dpavlin	997	$log->info("init Jifty");
130	dpavlin	932	my $path = $self->path \|\| confess "no path?";
131	dpavlin	993	my $webpac_dir = getcwd();
132			chdir $path \|\| $log->logdie("can't chdir($path) $!");
133	dpavlin	997	Jifty->new();
134	dpavlin	932
135	dpavlin	993	my $affected = 0;
136	dpavlin	985
137	dpavlin	993	foreach my $type ( $self->consume_outputs ) {
138			next unless defined $fields->{$type};
139	dpavlin	997	$affected += $self->_sync_field(
140			$self->database, $type, $fields->{$type}
141			);
142	dpavlin	993	}
143
144	dpavlin	997
145
146			my $glue_path = "$path/lib/Webpacus/Webpac.pm";
147
148			$log->debug("creating clue class Webpacus::Webpac at $glue_path");
149
150			my $glue = <<"_END_OF_GLUE_";
151			package Webpacus::Webpac;
152
153			=head1 NAME
154
155			Webpacus::Webpac - configuration exported from WebPAC
156
157			=cut
158
159			use strict;
160			use warnings;
161
162			sub index_path { '/data/webpac2/var/kinosearch/' };
163
164			1;
165			_END_OF_GLUE_
166
167			$log->debug("glue source:\n$glue");
168
169			write_file( $glue_path, $glue ) \|\| $log->logdie("can't create $glue_path: $!");
170
171	dpavlin	993	return $affected;
172			};
173
174			sub _sync_field {
175			my $self = shift;
176
177	dpavlin	997	my ( $database, $type, $field_hash ) = @_;
178
179	dpavlin	993	my $path = $self->path \|\| confess "no path?";
180
181			my $log = $self->_get_logger();
182
183	dpavlin	997	my $model = 'Webpacus::Model::' . ucfirst($type);
184			$log->info("sync $model");
185
186	dpavlin	993	$log->debug("field_hash = ",sub { dump($field_hash) });
187
188			my @field_names = keys %$field_hash;
189
190	dpavlin	985	if ( ! @field_names ) {
191			$log->warn("normalization rules don't produce any data for search!");
192			return;
193			}
194
195	dpavlin	997	$log->info("syncing $database $type fields: ", join(", ", @field_names));
196	dpavlin	985
197	dpavlin	932	my $system_user = Webpacus::CurrentUser->superuser;
198	dpavlin	997	my $o = $model->new(current_user => $system_user);
199	dpavlin	932
200	dpavlin	951	my ( $count, $new, $updated ) = ( 0, 0, 0 );
201	dpavlin	932
202	dpavlin	985	foreach my $field ( @field_names ) {
203	dpavlin	993	my $items = $field_hash->{$field} \|\| confess "no field?";
204	dpavlin	951
205	dpavlin	997	my ( $id, $msg ) = $o->load_by_cols(
206			name => $field,
207			from_database => $database,
208			);
209	dpavlin	951
210			if ( $id ) {
211			$o->set_items( $items );
212	dpavlin	997	$log->debug("updated $database $type field: $field [$items] ID: $id $msg");
213	dpavlin	951	$updated++;
214			} else {
215	dpavlin	997	$log->debug("adding $database $type field: $field [$items] $msg");
216	dpavlin	951	$o->create(
217			name => $field,
218	dpavlin	997	from_database => $database,
219	dpavlin	951	items => $items,
220			);
221			$new++;
222			}
223
224	dpavlin	932	$count++;
225			}
226
227	dpavlin	997	$log->info("synced $count fields (",join(", ", @field_names),") from $database with Webpacus ($new new/$updated updated) at $path");
228	dpavlin	933
229	dpavlin	932	return $count;
230
231			}
232
233	dpavlin	993	=head2 consume_outputs
234	dpavlin	932
235	dpavlin	993	Returns array with names of supported output types for this module
236
237			=cut
238
239			sub consume_outputs {
240			return qw/search sorted/;
241			}
242
243	dpavlin	932	=head1 AUTHOR
244
245			Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>
246
247			=head1 COPYRIGHT & LICENSE
248
249			Copyright 2007 Dobrica Pavlinusic, All Rights Reserved.
250
251			This program is free software; you can redistribute it and/or modify it
252			under the same terms as Perl itself.
253
254			=cut
255
256			1;