Merge branch 'new/bug_5307' into kcmaster
[wip/koha-chris_n.git] / admin / matching-rules.pl
1 #! /usr/bin/perl
2 #
3 # Copyright 2007 LibLime
4 #
5 # This file is part of Koha.
6 #
7 # Koha is free software; you can redistribute it and/or modify it under the
8 # terms of the GNU General Public License as published by the Free Software
9 # Foundation; either version 2 of the License, or (at your option) any later
10 # version.
11 #
12 # Koha is distributed in the hope that it will be useful, but WITHOUT ANY
13 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14 # A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
15 #
16 # You should have received a copy of the GNU General Public License along
17 # with Koha; if not, write to the Free Software Foundation, Inc.,
18 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 #
20
21 use strict;
22 use warnings;
23
24 use CGI;
25 use C4::Auth;
26 use C4::Context;
27 use C4::Output;
28 use C4::Koha;
29 use C4::Matcher;
30
31 my $script_name = "/cgi-bin/koha/admin/matching-rules.pl";
32
33 my $input = new CGI;
34 my $op = $input->param('op') || '';
35
36
37 my ($template, $loggedinuser, $cookie)
38     = get_template_and_user({template_name => "admin/matching-rules.tmpl",
39                  query => $input,
40                  type => "intranet",
41                  authnotrequired => 0,
42                  flagsrequired => {parameters => 1},
43                  debug => 1,
44                  });
45
46 $template->param(script_name => $script_name);
47
48 my $matcher_id = $input->param("matcher_id");
49
50 $template->param(max_matchpoint => 0);
51 $template->param(max_matchcheck => 0);
52 my $display_list = 0;
53 if ($op eq "edit_matching_rule") {
54     edit_matching_rule_form($template, $matcher_id);
55 } elsif ($op eq "edit_matching_rule_confirmed") {
56     add_update_matching_rule($template, $matcher_id);
57     $display_list = 1;
58 } elsif ($op eq "add_matching_rule") {
59     add_matching_rule_form($template);
60 } elsif ($op eq "add_matching_rule_confirmed") {
61     add_update_matching_rule($template, $matcher_id);
62     $display_list = 1;
63 } elsif ($op eq "delete_matching_rule") {
64     delete_matching_rule_form($template, $matcher_id);
65 } elsif ($op eq "delete_matching_rule_confirmed") {
66     delete_matching_rule($template, $matcher_id);
67     $display_list = 1;
68 } else {
69     $display_list = 1;
70 }
71
72 if ($display_list) {
73     matching_rule_list($template);
74 }
75
76 output_html_with_http_headers $input, $cookie, $template->output;
77
78 exit 0;
79
80 sub add_matching_rule_form {
81     my $template = shift;
82
83     $template->param(
84         matching_rule_form => 1,
85         confirm_op => 'add_matching_rule_confirmed',
86         max_matchpoint => 1,
87         max_matchcheck => 1
88     );
89
90 }
91
92 sub add_update_matching_rule {
93     my $template = shift;
94     my $matcher_id = shift;
95
96     # do parsing
97     my $matcher = C4::Matcher->new('biblio', 1000); # FIXME biblio only for now
98     $matcher->code($input->param('code'));
99     $matcher->description($input->param('description'));
100     $matcher->threshold($input->param('threshold'));
101
102     # matchpoints
103     my @mp_nums = sort map { /^mp_(\d+)_search_index/ ? int($1): () } $input->param;
104     foreach my $mp_num (@mp_nums) {
105         my $index = $input->param("mp_${mp_num}_search_index");
106         my $score = $input->param("mp_${mp_num}_score");
107         # components
108         my $components = [];
109         my @comp_nums = sort map { /^mp_${mp_num}_c_(\d+)_tag/ ? int($1): () } $input->param;
110         foreach my $comp_num (@comp_nums) {
111             my $component = {};
112             $component->{'tag'} = $input->param("mp_${mp_num}_c_${comp_num}_tag");
113             $component->{'subfields'} = $input->param("mp_${mp_num}_c_${comp_num}_subfields");
114             $component->{'offset'} = $input->param("mp_${mp_num}_c_${comp_num}_offset");
115             $component->{'length'} = $input->param("mp_${mp_num}_c_${comp_num}_length");
116             # norms
117             $component->{'norms'} = [];
118             my @norm_nums = sort map { /^mp_${mp_num}_c_${comp_num}_n_(\d+)_norm/ ? int($1): () } $input->param;
119             foreach my $norm_num (@norm_nums) {
120                 push @{ $component->{'norms'} }, $input->param("mp_${mp_num}_c_${comp_num}_n_${norm_num}_norm");
121             }
122             push @$components, $component;
123         }
124         $matcher->add_matchpoint($index, $score, $components);
125     }
126
127     # match checks
128     my @mc_nums = sort map { /^mc_(\d+)_id/ ? int($1): () } $input->param;
129     foreach my $mc_num (@mp_nums) {
130         # source components
131         my $src_components = [];
132         my @src_comp_nums = sort map { /^mc_${mc_num}_src_c_(\d+)_tag/ ? int($1): () } $input->param;
133         foreach my $comp_num (@src_comp_nums) {
134             my $component = {};
135             $component->{'tag'} = $input->param("mc_${mc_num}_src_c_${comp_num}_tag");
136             $component->{'subfields'} = $input->param("mc_${mc_num}_src_c_${comp_num}_subfields");
137             $component->{'offset'} = $input->param("mc_${mc_num}_src_c_${comp_num}_offset");
138             $component->{'length'} = $input->param("mc_${mc_num}_src_c_${comp_num}_length");
139             # norms
140             $component->{'norms'} = [];
141             my @norm_nums = sort map { /^mc_${mc_num}_src_c_${comp_num}_n_(\d+)_norm/ ? int($1): () } $input->param;
142             foreach my $norm_num (@norm_nums) {
143                 push @{ $component->{'norms'} }, $input->param("mc_${mc_num}_src_c_${comp_num}_n_${norm_num}_norm");
144             }
145             push @$src_components, $component;
146         }
147         # target components
148         my $tgt_components = [];
149         my @tgt_comp_nums = sort map { /^mc_${mc_num}_tgt_c_(\d+)_tag/ ? int($1): () } $input->param;
150         foreach my $comp_num (@tgt_comp_nums) {
151             my $component = {};
152             $component->{'tag'} = $input->param("mc_${mc_num}_tgt_c_${comp_num}_tag");
153             $component->{'subfields'} = $input->param("mc_${mc_num}_tgt_c_${comp_num}_subfields");
154             $component->{'offset'} = $input->param("mc_${mc_num}_tgt_c_${comp_num}_offset");
155             $component->{'length'} = $input->param("mc_${mc_num}_tgt_c_${comp_num}_length");
156             # norms
157             $component->{'norms'} = [];
158             my @norm_nums = sort map { /^mc_${mc_num}_tgt_c_${comp_num}_n_(\d+)_norm/ ? int($1): () } $input->param;
159             foreach my $norm_num (@norm_nums) {
160                 push @{ $component->{'norms'} }, $input->param("mc_${mc_num}_tgt_c_${comp_num}_n_${norm_num}_norm");
161             }
162             push @$tgt_components, $component;
163         }
164         $matcher->add_required_check($src_components, $tgt_components);
165     }
166     
167     if (defined $matcher_id and $matcher_id =~ /^\d+/) {
168         $matcher->_id($matcher_id);
169         $template->param(edited_matching_rule => $matcher->code());
170     } else {
171         $template->param(added_matching_rule => $matcher->code());
172     }
173     $matcher_id = $matcher->store();
174 }
175
176 sub delete_matching_rule_form {
177     my $template = shift;
178     my $matcher_id = shift;
179
180     my $matcher = C4::Matcher->fetch($matcher_id);
181     $template->param(
182         delete_matching_rule_form => 1,
183         confirm_op => "delete_matching_rule_confirmed",
184         matcher_id => $matcher_id,
185         code => $matcher->code(),
186         description => $matcher->description(),
187     );
188 }
189
190 sub delete_matching_rule {
191     my $template = shift;
192     my $matcher_id = shift;
193
194     my $matcher = C4::Matcher->fetch($matcher_id);
195     $template->param(deleted_matching_rule => $matcher->code(),
196                     );
197     C4::Matcher->delete($matcher_id);
198 }
199
200 sub edit_matching_rule_form {
201     my $template = shift;
202     my $matcher_id = shift;
203
204     my $matcher = C4::Matcher->fetch($matcher_id);
205
206     $template->param(matcher_id => $matcher_id);
207     $template->param(code => $matcher->code());
208     $template->param(description => $matcher->description());
209     $template->param(threshold => $matcher->threshold());
210
211     my $matcher_info = $matcher->dump();
212     my @matchpoints = ();
213     my $mp_num = 0;
214     foreach my $matchpoint (@{ $matcher_info->{'matchpoints'} }) {
215         $mp_num++;
216         my @components = _parse_components($matchpoint->{'components'});
217         push @matchpoints, { 
218             mp_num => $mp_num, 
219             index => $matchpoint->{'index'}, 
220             score => $matchpoint->{'score'},
221             components => \@components
222         };        
223     }
224     $template->param(matchpoints => \@matchpoints);
225
226     my $mc_num = 0;
227     my @matchchecks = ();
228     foreach my $matchcheck (@{ $matcher_info->{'matchchecks'} }) {
229         $mc_num++;
230         my @src_components = _parse_components($matchcheck->{'source_matchpoint'}->{'components'});
231         my @tgt_components = _parse_components($matchcheck->{'target_matchpoint'}->{'components'});
232         push @matchchecks, {
233             mc_num => $mc_num,
234             src_components => \@src_components,
235             tgt_components => \@tgt_components
236         };
237     }
238     $template->param(matchchecks => \@matchchecks);
239
240     $template->param(
241         matching_rule_form => 1,
242         edit_matching_rule => 1,
243         confirm_op => 'edit_matching_rule_confirmed',
244         max_matchpoint => $mp_num,
245         max_matchcheck => $mc_num
246     );
247
248 }
249
250 sub _parse_components {
251     my $components_ref = shift;
252     my @components = ();
253
254     my $comp_num = 0;
255     foreach my $component (@{ $components_ref  }) {
256         $comp_num++;
257         my $norm_num = 0;
258         my @norms;
259         foreach my $norm (@{ $component->{'norms'} }) {
260             $norm_num++;
261             push @norms, { norm_num => $norm_num, norm => $norm };
262         }
263         push @components, {
264             comp_num => $comp_num,
265             tag => $component->{'tag'},
266             subfields => join("", sort keys %{ $component->{'subfields'} }),
267             offset => $component->{'offset'},
268             'length' => $component->{'length'},
269             norms => \@norms
270         };
271     }
272
273     return @components;
274 }
275
276 sub matching_rule_list {
277     my $template = shift;
278     
279     my @matching_rules = C4::Matcher::GetMatcherList();
280     $template->param(available_matching_rules => \@matching_rules);
281     $template->param(display_list => 1);
282 }