You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
956 lines
32 KiB
956 lines
32 KiB
package NGCP::Panel::Utils::HeaderManipulations;
|
|
use NGCP::Panel::Utils::Generic qw(:all);
|
|
|
|
use strict;
|
|
use warnings;
|
|
|
|
use Sipwise::Base;
|
|
use NGCP::Panel::Utils::Datatables;
|
|
use NGCP::Panel::Utils::DateTime;
|
|
use NGCP::Panel::Utils::Message;
|
|
|
|
sub update_condition {
|
|
my %params = @_;
|
|
my ($c, $item, $resource) = @params{qw/c item resource/};
|
|
|
|
my $schema = $c->model('DB');
|
|
|
|
my $values = delete $resource->{values} // [];
|
|
map { $_->{condition_id} = $item->id } @{$values};
|
|
|
|
$item->update($resource);
|
|
$item->values->delete;
|
|
|
|
$schema->resultset('voip_header_rule_condition_values')
|
|
->populate($values);
|
|
|
|
$resource->{values} = $values;
|
|
$item->discard_changes()
|
|
}
|
|
|
|
sub invalidate_ruleset {
|
|
my %params = @_;
|
|
my ($c, $set_id) = @params{qw/c set_id/};
|
|
|
|
my $schema = $c->model('DB');
|
|
my $path = "/hm_invalidate_ruleset/";
|
|
my $target = "proxy-ng";
|
|
|
|
$c->log->info("invalidate ruleset to target=$target path=$path set_id=$set_id");
|
|
|
|
my $hosts;
|
|
my $host_rs = $schema->resultset('xmlgroups')
|
|
->search_rs({name => $target})
|
|
->search_related('xmlhostgroups')->search_related('host', {}, { order_by => 'id' });
|
|
$hosts = [map { +{ip => $_->ip, port => $_->port,
|
|
id => $_->id} } $host_rs->all];
|
|
|
|
my %headers = (
|
|
"User-Agent" => "Sipwise HTTP Dispatcher",
|
|
"Content-Type" => "text/plain",
|
|
"P-NGCP-HM-Invalidate-Rule-Set" => $set_id,
|
|
);
|
|
|
|
my @err;
|
|
|
|
foreach my $host (@$hosts) {
|
|
my ($method, $ip, $port, $id) =
|
|
("http", $host->{ip}, $host->{port}, $host->{id});
|
|
my $hostid = "id=$id $ip:$port";
|
|
$c->log->info("dispatching http request to ".$hostid.$path);
|
|
|
|
eval {
|
|
my $s = Net::HTTP->new(Host => $ip, KeepAlive => 0, PeerPort => $port, Timeout => 5);
|
|
$s or die "could not connect to server $hostid";
|
|
|
|
my $res = $s->write_request("POST", $path || "/", %headers, $set_id);
|
|
$res or die "did not get result from $hostid";
|
|
|
|
my ($code, $status, @hdrs) = $s->read_response_headers();
|
|
unless ($code == 200) {
|
|
push @err, "$hostid: $code $status";
|
|
}
|
|
};
|
|
|
|
if ($@) {
|
|
my $msg = "$hostid: $@";
|
|
push @err, $msg;
|
|
$c->log->info("failure: $msg");
|
|
}
|
|
}
|
|
|
|
return \@err;
|
|
}
|
|
|
|
sub get_subscriber_set {
|
|
my %params = @_;
|
|
my ($c, $prov_subscriber_id) = @params{qw/c subscriber_id/};
|
|
|
|
return unless $prov_subscriber_id;
|
|
|
|
my $schema = $c->model('DB');
|
|
|
|
return $schema->resultset('voip_header_rule_sets')->find({
|
|
subscriber_id => $prov_subscriber_id
|
|
});
|
|
}
|
|
|
|
sub create_subscriber_set {
|
|
my %params = @_;
|
|
my ($c, $prov_subscriber_id) = @params{qw/c subscriber_id/};
|
|
|
|
return unless $prov_subscriber_id;
|
|
|
|
my $schema = $c->model('DB');
|
|
|
|
my $sub_set = $schema->resultset('voip_header_rule_sets')->find({
|
|
subscriber_id => $prov_subscriber_id
|
|
});
|
|
|
|
return $sub_set if $sub_set;
|
|
|
|
my $prov_subscriber = $schema->resultset('provisioning_voip_subscribers')->find($prov_subscriber_id);
|
|
return unless $prov_subscriber;
|
|
my $subscriber = $prov_subscriber->voip_subscriber;
|
|
$sub_set = $schema->resultset('voip_header_rule_sets')->create({
|
|
reseller_id => $subscriber->contract->contact->reseller_id,
|
|
subscriber_id => $prov_subscriber_id,
|
|
name => 'subscriber_'.$subscriber->id,
|
|
description => '',
|
|
});
|
|
$sub_set->discard_changes;
|
|
|
|
return $sub_set;
|
|
}
|
|
|
|
sub cleanup_subscriber_set {
|
|
my %params = @_;
|
|
my ($c, $prov_subscriber_id) = @params{qw/c subscriber_id/};
|
|
|
|
return unless $prov_subscriber_id;
|
|
|
|
my $schema = $c->model('DB');
|
|
|
|
my $set_rs = $schema->resultset('voip_header_rule_sets')->search({
|
|
subscriber_id => $prov_subscriber_id
|
|
});
|
|
|
|
return unless $set_rs && $set_rs->first;
|
|
|
|
return if $set_rs->first->voip_header_rules->count;
|
|
|
|
$set_rs->first->delete;
|
|
|
|
return;
|
|
}
|
|
|
|
sub ui_rules_list {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $schema = $c->model('DB');
|
|
|
|
my $rules_rs;
|
|
if ($c->stash->{hm_set_result}) {
|
|
$rules_rs = $c->stash->{hm_set_result}->voip_header_rules({
|
|
},{
|
|
order_by => { -asc => 'priority' },
|
|
});
|
|
} else {
|
|
$rules_rs = $schema->resultset('voip_header_rules')->search({
|
|
set_id => 0
|
|
});
|
|
}
|
|
$c->stash(hm_rules_rs => $rules_rs);
|
|
|
|
$c->stash->{hm_rule_dt_columns} = NGCP::Panel::Utils::Datatables::set_columns($c, [
|
|
{ name => 'priority', search => 0, title => $c->loc('Priority') },
|
|
{ name => 'id', search => 1, title => $c->loc('#') },
|
|
{ name => 'name', search => 1, title => $c->loc('Name') },
|
|
{ name => 'description', search => 1, title => $c->loc('Description') },
|
|
{ name => 'direction', search => 1, title => $c->loc('Direction') },
|
|
{ name => 'stopper', search => 1, title => $c->loc('Stopper') },
|
|
{ name => 'enabled', search => 1, title => $c->loc('Enabled') },
|
|
]);
|
|
|
|
return;
|
|
}
|
|
|
|
sub ui_rules_root {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $rules_rs = $c->stash->{hm_rules_rs};
|
|
my $param_move = $c->req->params->{move};
|
|
my $param_where = $c->req->params->{where};
|
|
|
|
if ($param_move && is_int($param_move) && $param_where) {
|
|
my $elem = $rules_rs->find($param_move);
|
|
my $use_next = ($param_where eq "down") ? 1 : 0;
|
|
my $swap_elem = $rules_rs->search({
|
|
priority => { ($use_next ? '>' : '<') => $elem->priority },
|
|
},{
|
|
order_by => {($use_next ? '-asc' : '-desc') => 'priority'},
|
|
})->first;
|
|
try {
|
|
if ($swap_elem) {
|
|
my $tmp_priority = $swap_elem->priority;
|
|
$swap_elem->priority($elem->priority);
|
|
$elem->priority($tmp_priority);
|
|
$swap_elem->update;
|
|
$elem->update;
|
|
} elsif ($use_next) {
|
|
my $last_priority = $c->stash->{hm_rules_rs}->get_column('priority')->max() || 99;
|
|
$elem->priority(int($last_priority) + 1);
|
|
$elem->update;
|
|
} else {
|
|
my $last_priority = $c->stash->{hm_rules_rs}->get_column('priority')->min() || 1;
|
|
$elem->priority(int($last_priority) - 1);
|
|
$elem->update;
|
|
}
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to move header rule.'),
|
|
);
|
|
}
|
|
}
|
|
|
|
$c->stash(hm_rules => [ $rules_rs->all ]);
|
|
return;
|
|
}
|
|
|
|
sub ui_rules_ajax {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $rs = $c->stash->{hm_rules_rs};
|
|
NGCP::Panel::Utils::Datatables::process($c, $rs, $c->stash->{hm_rule_dt_columns});
|
|
$c->detach( $c->view("JSON") );
|
|
}
|
|
|
|
sub ui_rules_base {
|
|
my %params = @_;
|
|
my ($c, $rule_id) = @params{qw/c rule_id/};
|
|
|
|
unless($rule_id && is_int($rule_id)) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
log => 'Invalid header rule id detected',
|
|
desc => $c->loc('Invalid header rule id detected'),
|
|
);
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_rules_uri});
|
|
}
|
|
|
|
my $res = $c->stash->{hm_rules_rs}->find($rule_id);
|
|
unless(defined($res)) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
log => 'Header rule does not exist',
|
|
desc => $c->loc('Header rule does not exist'),
|
|
);
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_rules_uri});
|
|
}
|
|
$c->stash(hm_rule_result => $res);
|
|
return;
|
|
}
|
|
|
|
sub ui_rules_edit {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $posted = ($c->request->method eq 'POST');
|
|
my $form = NGCP::Panel::Form::get("NGCP::Panel::Form::Header::Rule", $c);
|
|
$form->process(
|
|
posted => $posted,
|
|
params => $c->request->params,
|
|
item => $c->stash->{hm_rule_result},
|
|
);
|
|
NGCP::Panel::Utils::Navigation::check_form_buttons(
|
|
c => $c,
|
|
form => $form,
|
|
fields => {},
|
|
back_uri => $c->req->uri,
|
|
);
|
|
if($posted && $form->validated) {
|
|
try {
|
|
$c->stash->{hm_rule_result}->update($form->values);
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
NGCP::Panel::Utils::Message::info(
|
|
c => $c,
|
|
desc => $c->loc('Header rule successfully updated'),
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to update header rule'),
|
|
);
|
|
}
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_rules_uri});
|
|
}
|
|
|
|
$c->stash(form => $form);
|
|
$c->stash(edit_flag => 1);
|
|
}
|
|
|
|
sub ui_rules_delete {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
try {
|
|
my $rule_res = delete $c->stash->{hm_rule_result};
|
|
my %hm_rule_columns = $rule_res->get_inflated_columns;
|
|
$rule_res->delete;
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
if ($c->stash->{subscriber}) {
|
|
$rule_res->discard_changes;
|
|
my $rules_cnt = NGCP::Panel::Utils::HeaderManipulations::cleanup_subscriber_set(
|
|
c => $c,
|
|
subscriber_id =>
|
|
$c->stash->{subscriber}->provisioning_voip_subscriber->id
|
|
);
|
|
if ($c->stash->{subscriber} && !$rules_cnt) {
|
|
delete $c->stash->{hm_set_result};
|
|
}
|
|
}
|
|
NGCP::Panel::Utils::Message::info(
|
|
c => $c,
|
|
data => \%hm_rule_columns,
|
|
desc => $c->loc('Header rule successfully deleted'),
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to delete header rule'),
|
|
);
|
|
};
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_rules_uri});
|
|
return;
|
|
}
|
|
|
|
sub ui_rules_create {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $posted = ($c->request->method eq 'POST');
|
|
my $form = NGCP::Panel::Form::get("NGCP::Panel::Form::Header::Rule", $c);
|
|
$form->process(
|
|
posted => $posted,
|
|
params => $c->request->params,
|
|
);
|
|
NGCP::Panel::Utils::Navigation::check_form_buttons(
|
|
c => $c,
|
|
form => $form,
|
|
fields => {},
|
|
back_uri => $c->req->uri,
|
|
);
|
|
if($posted && $form->validated) {
|
|
try {
|
|
if (!$c->stash->{hm_set_result} && $c->stash->{subscriber}) {
|
|
$c->stash->{hm_set_result} =
|
|
NGCP::Panel::Utils::HeaderManipulations::create_subscriber_set(
|
|
c => $c,
|
|
subscriber_id =>
|
|
$c->stash->{subscriber}->provisioning_voip_subscriber->id
|
|
) || die "could not create a subscriber header rule set";
|
|
$c->stash->{hm_rules_rs} = $c->stash->{hm_set_result}->voip_header_rules;
|
|
}
|
|
my $last_priority = $c->stash->{hm_rules_rs}->get_column('priority')->max() || 99;
|
|
$form->values->{priority} = int($last_priority) + 1;
|
|
$c->stash->{hm_rules_rs}->create($form->values)->discard_changes;
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
NGCP::Panel::Utils::Message::info(
|
|
c => $c,
|
|
desc => $c->loc('Header rule successfully created'),
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to create a header rule'),
|
|
);
|
|
}
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_rules_uri});
|
|
}
|
|
|
|
$c->stash(form => $form);
|
|
$c->stash(create_flag => 1);
|
|
return;
|
|
}
|
|
|
|
sub ui_conditions_list {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $conditions_rs = $c->stash->{hm_rule_result}->conditions;
|
|
|
|
$c->stash(hm_conditions_rs => $conditions_rs);
|
|
|
|
$c->stash->{hm_condition_dt_columns} = NGCP::Panel::Utils::Datatables::set_columns($c, [
|
|
{ name => 'id', search => 1, title => $c->loc('#') },
|
|
{ name => 'match_type', search => 1, title => $c->loc('Match') },
|
|
{ name => 'match_part', search => 1, title => $c->loc('Part') },
|
|
{ name => 'match_name', search => 1, title => $c->loc('Name') },
|
|
{ name => 'expression', search => 1, title => $c->loc('Expression') },
|
|
{ name => 'value_type', search => 1, title => $c->loc('Type') },
|
|
{ name => 'c_values', search => 0, title => $c->loc('Values') },
|
|
{ name => 'c_rwr_set', search => 0, title => $c->loc('Rewrite Rule Set') },
|
|
{ name => 'enabled', search => 1, title => $c->loc('Enabled') },
|
|
]);
|
|
|
|
return;
|
|
}
|
|
|
|
sub ui_conditions_root {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $conditions_rs = $c->stash->{hm_conditions_rs};
|
|
|
|
$c->stash(hm_conditions => [ $conditions_rs->all ] );
|
|
|
|
return;
|
|
}
|
|
|
|
sub ui_conditions_ajax {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $rs = $c->stash->{hm_conditions_rs};
|
|
NGCP::Panel::Utils::Datatables::process($c, $rs, $c->stash->{hm_condition_dt_columns}, sub {
|
|
my $item = shift;
|
|
my %cols = $item->get_inflated_columns;
|
|
my ($c_rwr_set, $c_rwr_dp) = ('','');
|
|
if ($cols{rwr_set_id}) {
|
|
my %rwr_set = $item->rwr_set->get_inflated_columns;
|
|
$c_rwr_set = $rwr_set{name};
|
|
my $dp_id = $cols{rwr_dp_id} // 0;
|
|
($c_rwr_dp) =
|
|
grep { $_ =~ /_dpid/ && $rwr_set{$_} eq $dp_id }
|
|
keys %rwr_set;
|
|
$c_rwr_dp =~ s/_dpid$//;
|
|
}
|
|
return (
|
|
expression => ($cols{expression_negation} ? ' ! ' : ' ') . $cols{expression},
|
|
c_values => join("<br/>", map { $_->value } $item->values->all) // '',
|
|
c_rwr_set => $c_rwr_set ? "$c_rwr_set ($c_rwr_dp)" : '',
|
|
);
|
|
});
|
|
$c->detach( $c->view("JSON") );
|
|
}
|
|
|
|
sub ui_conditions_base {
|
|
my %params = @_;
|
|
my ($c, $condition_id) = @params{qw/c condition_id/};
|
|
|
|
$c->stash(hm_conditions_uri => $c->uri_for_action("/header/conditions_root",
|
|
[$c->stash->{hm_set_result}->id, $c->stash->{hm_rule_result}->id])
|
|
);
|
|
|
|
unless ($condition_id && is_int($condition_id)) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
log => 'Invalid header rule condition id detected',
|
|
desc => $c->loc('Invalid header rule condition id detected'),
|
|
);
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_conditions_uri});
|
|
}
|
|
|
|
my $res = $c->stash->{hm_conditions_rs}->find($condition_id);
|
|
unless (defined($res)) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
log => 'Header rule condition does not exist',
|
|
desc => $c->loc('Header rule condition does not exist'),
|
|
);
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_conditions_uri});
|
|
}
|
|
$c->stash(hm_condition_result => $res);
|
|
|
|
return;
|
|
}
|
|
|
|
sub ui_conditions_edit {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $posted = ($c->request->method eq 'POST');
|
|
my $form = NGCP::Panel::Form::get("NGCP::Panel::Form::Header::Condition", $c);
|
|
my $condition = $c->stash->{hm_condition_result};
|
|
my $params = {};
|
|
|
|
unless ($posted) {
|
|
$params = { $condition->get_inflated_columns };
|
|
@{$params->{values}} =
|
|
map { { $_->get_inflated_columns } } $condition->values->all;
|
|
if ($params->{rwr_set_id}) {
|
|
my $rwr_set = { $condition->rwr_set->get_inflated_columns };
|
|
$params->{rwr_set} = $rwr_set->{id};
|
|
my $dp_id = $params->{rwr_dp_id} // 0;
|
|
($params->{rwr_dp}) =
|
|
grep { $_ =~ /_dpid/ && $rwr_set->{$_} eq $dp_id }
|
|
keys %{$rwr_set};
|
|
}
|
|
}
|
|
|
|
$form->process(params => $posted ? $c->req->params : $params);
|
|
NGCP::Panel::Utils::Navigation::check_form_buttons(
|
|
c => $c,
|
|
form => $form,
|
|
fields => {},
|
|
back_uri => $c->req->uri,
|
|
);
|
|
if($posted && $form->validated) {
|
|
try {
|
|
my $guard = $c->model('DB')->txn_scope_guard;
|
|
{
|
|
my $data = $form->values;
|
|
if ($data->{rwr_set}) {
|
|
$data->{rwr_set_id} = delete $data->{rwr_set};
|
|
my $rwr_rs = $c->model('DB')
|
|
->resultset('voip_rewrite_rule_sets')
|
|
->search({ id => $data->{rwr_set_id} });
|
|
if ($rwr_rs->count) {
|
|
my $rwr_set = { $rwr_rs->first->get_inflated_columns };
|
|
$data->{rwr_dp_id} = $rwr_set->{$data->{rwr_dp}} // undef;
|
|
} else {
|
|
$data->{rwr_set_id} = undef;
|
|
$data->{rwr_dp_id} = undef;
|
|
}
|
|
} else {
|
|
$data->{rwr_set_id} = undef;
|
|
$data->{rwr_dp_id} = undef;
|
|
}
|
|
delete $data->{rwr_set};
|
|
delete $data->{rwr_dp};
|
|
|
|
NGCP::Panel::Utils::HeaderManipulations::update_condition(
|
|
c => $c, resource => $data, item => $condition
|
|
);
|
|
}
|
|
$guard->commit;
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
NGCP::Panel::Utils::Message::info(
|
|
c => $c,
|
|
desc => $c->loc('Header rule condition successfully updated'),
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to update header rule condition'),
|
|
);
|
|
}
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_conditions_uri});
|
|
}
|
|
|
|
$c->stash(form => $form);
|
|
$c->stash(edit_flag => 1);
|
|
}
|
|
|
|
sub ui_conditions_delete {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
try {
|
|
$c->stash->{hm_condition_result}->delete;
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
NGCP::Panel::Utils::Message::info(
|
|
c => $c,
|
|
data => { $c->stash->{hm_condition_result}->get_inflated_columns },
|
|
desc => $c->loc('Header rule condition successfully deleted'),
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to delete header rule condition'),
|
|
);
|
|
};
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_conditions_uri});
|
|
}
|
|
|
|
sub ui_conditions_create {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $posted = ($c->request->method eq 'POST');
|
|
my $form = NGCP::Panel::Form::get("NGCP::Panel::Form::Header::Condition", $c);
|
|
$form->process(
|
|
posted => $posted,
|
|
params => $c->request->params,
|
|
);
|
|
NGCP::Panel::Utils::Navigation::check_form_buttons(
|
|
c => $c,
|
|
form => $form,
|
|
fields => {},
|
|
back_uri => $c->req->uri,
|
|
);
|
|
if($posted && $form->validated) {
|
|
try {
|
|
my $guard = $c->model('DB')->txn_scope_guard;
|
|
{
|
|
my $data = $form->values;
|
|
$data->{rule_id} = $c->stash->{hm_rule_result}->id;
|
|
|
|
if ($data->{rwr_set}) {
|
|
$data->{rwr_set_id} = delete $data->{rwr_set};
|
|
my $rwr_rs = $c->model('DB')
|
|
->resultset('voip_rewrite_rule_sets')
|
|
->search({ id => $data->{rwr_set_id} });
|
|
if ($rwr_rs->count) {
|
|
my $rwr_set = { $rwr_rs->first->get_inflated_columns };
|
|
$data->{rwr_dp_id} = $rwr_set->{$data->{rwr_dp}} // undef;
|
|
} else {
|
|
$data->{rwr_set_id} = undef;
|
|
$data->{rwr_dp_id} = undef;
|
|
}
|
|
} else {
|
|
$data->{rwr_set_id} = undef;
|
|
$data->{rwr_dp_id} = undef;
|
|
}
|
|
delete $data->{rwr_set};
|
|
delete $data->{rwr_dp};
|
|
|
|
$c->stash->{hm_conditions_rs}->create($data);
|
|
}
|
|
$guard->commit;
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
NGCP::Panel::Utils::Message::info(
|
|
c => $c,
|
|
desc => $c->loc('Header rule condition successfully created'),
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to create a header rule condition'),
|
|
);
|
|
}
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_conditions_uri});
|
|
}
|
|
|
|
$c->stash(form => $form);
|
|
$c->stash(create_flag => 1);
|
|
}
|
|
|
|
sub ui_actions_list {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $actions_rs = $c->stash->{hm_rule_result}->actions({
|
|
},{
|
|
order_by => { -asc => 'priority' },
|
|
});
|
|
$c->stash(hm_actions_rs => $actions_rs);
|
|
|
|
$c->stash->{hm_action_dt_columns} = NGCP::Panel::Utils::Datatables::set_columns($c, [
|
|
{ name => 'priority', search => 0, title => $c->loc('Priority') },
|
|
{ name => 'id', search => 1, title => $c->loc('#') },
|
|
{ name => 'header', search => 1, title => $c->loc('Header') },
|
|
{ name => 'header_part', search => 1, title => $c->loc('Part') },
|
|
{ name => 'action_type', search => 1, title => $c->loc('Type') },
|
|
{ name => 'value_part', search => 1, title => $c->loc('Value Part') },
|
|
{ name => 'value', search => 1, title => $c->loc('Value') },
|
|
{ name => 'c_rwr_set', search => 0, title => $c->loc('Rewrite Rule Set') },
|
|
{ name => 'enabled', search => 1, title => $c->loc('Enabled') },
|
|
]);
|
|
|
|
return;
|
|
}
|
|
|
|
sub ui_actions_root {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $actions_rs = $c->stash->{hm_actions_rs};
|
|
my $param_move = $c->req->params->{move};
|
|
my $param_where = $c->req->params->{where};
|
|
|
|
if ($param_move && is_int($param_move) && $param_where) {
|
|
my $elem = $actions_rs->find($param_move);
|
|
my $use_next = ($param_where eq "down") ? 1 : 0;
|
|
my $swap_elem = $actions_rs->search({
|
|
priority => { ($use_next ? '>' : '<') => $elem->priority },
|
|
},{
|
|
order_by => {($use_next ? '-asc' : '-desc') => 'priority'},
|
|
})->first;
|
|
try {
|
|
if ($swap_elem) {
|
|
my $tmp_priority = $swap_elem->priority;
|
|
$swap_elem->priority($elem->priority);
|
|
$elem->priority($tmp_priority);
|
|
$swap_elem->update;
|
|
$elem->update;
|
|
} elsif ($use_next) {
|
|
my $last_priority = $c->stash->{hm_actions_rs}->get_column('priority')->max() || 99;
|
|
$elem->priority(int($last_priority) + 1);
|
|
$elem->update;
|
|
} else {
|
|
my $last_priority = $c->stash->{hm_actions_rs}->get_column('priority')->min() || 1;
|
|
$elem->priority(int($last_priority) - 1);
|
|
$elem->update;
|
|
}
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to move action.'),
|
|
);
|
|
}
|
|
}
|
|
|
|
$c->stash(hm_actions => [ $actions_rs->all ]);
|
|
|
|
return;
|
|
}
|
|
|
|
sub ui_actions_ajax {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $rs = $c->stash->{hm_actions_rs};
|
|
NGCP::Panel::Utils::Datatables::process($c, $rs, $c->stash->{hm_action_dt_columns}, sub {
|
|
my $item = shift;
|
|
my %cols = $item->get_inflated_columns;
|
|
my ($c_rwr_set, $c_rwr_dp) = ('','');
|
|
if ($cols{rwr_set_id}) {
|
|
my %rwr_set = $item->rwr_set->get_inflated_columns;
|
|
$c_rwr_set = $rwr_set{name};
|
|
my $dp_id = $cols{rwr_dp_id} // 0;
|
|
($c_rwr_dp) =
|
|
grep { $_ =~ /_dpid/ && $rwr_set{$_} eq $dp_id }
|
|
keys %rwr_set;
|
|
$c_rwr_dp =~ s/_dpid$//;
|
|
}
|
|
return (
|
|
c_rwr_set => $c_rwr_set ? "$c_rwr_set ($c_rwr_dp)" : '',
|
|
);
|
|
});
|
|
$c->detach( $c->view("JSON") );
|
|
}
|
|
|
|
sub ui_actions_base {
|
|
my %params = @_;
|
|
my ($c, $action_id) = @params{qw/c action_id/};
|
|
|
|
$c->stash(hm_actions_uri => $c->uri_for_action("/header/actions_root",
|
|
[$c->stash->{hm_set_result}->id, $c->stash->{hm_rule_result}->id])
|
|
);
|
|
|
|
unless ($action_id && is_int($action_id)) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
log => 'Invalid header rule action id detected',
|
|
desc => $c->loc('Invalid header rule action id detected'),
|
|
);
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_actions_uri});
|
|
}
|
|
|
|
my $res = $c->stash->{hm_actions_rs}->find($action_id);
|
|
unless (defined($res)) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
log => 'Header rule action does not exist',
|
|
desc => $c->loc('Header rule action does not exist'),
|
|
);
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_actions_uri});
|
|
}
|
|
$c->stash(hm_action_result => $res);
|
|
|
|
return;
|
|
}
|
|
|
|
sub ui_actions_edit {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $posted = ($c->request->method eq 'POST');
|
|
my $form = NGCP::Panel::Form::get("NGCP::Panel::Form::Header::Action", $c);
|
|
my $action = $c->stash->{hm_action_result};
|
|
my $params = {};
|
|
|
|
unless ($posted) {
|
|
$params = { $action->get_inflated_columns };
|
|
if ($params->{rwr_set_id}) {
|
|
my $rwr_set = { $action->rwr_set->get_inflated_columns };
|
|
$params->{rwr_set} = $rwr_set->{id};
|
|
my $dp_id = $params->{rwr_dp_id} // 0;
|
|
($params->{rwr_dp}) =
|
|
grep { $_ =~ /_dpid/ && $rwr_set->{$_} eq $dp_id }
|
|
keys %{$rwr_set};
|
|
}
|
|
}
|
|
|
|
$form->process(params => $posted ? $c->req->params : $params);
|
|
NGCP::Panel::Utils::Navigation::check_form_buttons(
|
|
c => $c,
|
|
form => $form,
|
|
fields => {},
|
|
back_uri => $c->req->uri,
|
|
);
|
|
if($posted && $form->validated) {
|
|
try {
|
|
my $guard = $c->model('DB')->txn_scope_guard;
|
|
{
|
|
my $data = $form->values;
|
|
|
|
if ($data->{rwr_set}) {
|
|
$data->{rwr_set_id} = delete $data->{rwr_set};
|
|
my $rwr_rs = $c->model('DB')
|
|
->resultset('voip_rewrite_rule_sets')
|
|
->search({ id => $data->{rwr_set_id} });
|
|
if ($rwr_rs->count) {
|
|
my $rwr_set = { $rwr_rs->first->get_inflated_columns };
|
|
$data->{rwr_dp_id} = $rwr_set->{$data->{rwr_dp}} // undef;
|
|
} else {
|
|
$data->{rwr_set_id} = undef;
|
|
$data->{rwr_dp_id} = undef;
|
|
}
|
|
} else {
|
|
$data->{rwr_set_id} = undef;
|
|
$data->{rwr_dp_id} = undef;
|
|
}
|
|
delete $data->{rwr_set};
|
|
delete $data->{rwr_dp};
|
|
|
|
$action->update($data);
|
|
}
|
|
$guard->commit;
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
NGCP::Panel::Utils::Message::info(
|
|
c => $c,
|
|
desc => $c->loc('Header rule action successfully updated'),
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to update header rule action'),
|
|
);
|
|
}
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_actions_uri});
|
|
}
|
|
|
|
$c->stash(form => $form);
|
|
$c->stash(edit_flag => 1);
|
|
}
|
|
|
|
sub ui_actions_delete {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
try {
|
|
$c->stash->{hm_action_result}->delete;
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
NGCP::Panel::Utils::Message::info(
|
|
c => $c,
|
|
data => { $c->stash->{hm_action_result}->get_inflated_columns },
|
|
desc => $c->loc('Header rule action successfully deleted'),
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to delete header rule action'),
|
|
);
|
|
};
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_actions_uri});
|
|
}
|
|
|
|
sub ui_actions_create {
|
|
my %params = @_;
|
|
my ($c) = @params{qw/c/};
|
|
|
|
my $posted = ($c->request->method eq 'POST');
|
|
my $form = NGCP::Panel::Form::get("NGCP::Panel::Form::Header::Action", $c);
|
|
$form->process(
|
|
posted => $posted,
|
|
params => $c->request->params,
|
|
);
|
|
NGCP::Panel::Utils::Navigation::check_form_buttons(
|
|
c => $c,
|
|
form => $form,
|
|
fields => {},
|
|
back_uri => $c->req->uri,
|
|
);
|
|
if($posted && $form->validated) {
|
|
try {
|
|
my $guard = $c->model('DB')->txn_scope_guard;
|
|
{
|
|
my $data = $form->values;
|
|
$data->{rule_id} = $c->stash->{hm_rule_result}->id;
|
|
|
|
if ($data->{rwr_set}) {
|
|
$data->{rwr_set_id} = delete $data->{rwr_set};
|
|
my $rwr_rs = $c->model('DB')
|
|
->resultset('voip_rewrite_rule_sets')
|
|
->search({ id => $data->{rwr_set_id} });
|
|
if ($rwr_rs->count) {
|
|
my $rwr_set = { $rwr_rs->first->get_inflated_columns };
|
|
$data->{rwr_dp_id} = $rwr_set->{$data->{rwr_dp}} // undef;
|
|
} else {
|
|
$data->{rwr_set_id} = undef;
|
|
$data->{rwr_dp_id} = undef;
|
|
}
|
|
} else {
|
|
$data->{rwr_set_id} = undef;
|
|
$data->{rwr_dp_id} = undef;
|
|
}
|
|
delete $data->{rwr_set};
|
|
delete $data->{rwr_dp};
|
|
|
|
my $last_priority = $c->stash->{hm_actions_rs}->get_column('priority')->max() || 99;
|
|
$data->{priority} = int($last_priority) + 1;
|
|
|
|
$c->stash->{hm_actions_rs}->create($data);
|
|
}
|
|
$guard->commit;
|
|
NGCP::Panel::Utils::HeaderManipulations::invalidate_ruleset(
|
|
c => $c, set_id => $c->stash->{hm_set_result}->id
|
|
);
|
|
NGCP::Panel::Utils::Message::info(
|
|
c => $c,
|
|
desc => $c->loc('Header rule action successfully created'),
|
|
);
|
|
} catch($e) {
|
|
NGCP::Panel::Utils::Message::error(
|
|
c => $c,
|
|
error => $e,
|
|
desc => $c->loc('Failed to create a header rule action'),
|
|
);
|
|
}
|
|
NGCP::Panel::Utils::Navigation::back_or($c, $c->stash->{hm_actions_uri});
|
|
}
|
|
|
|
$c->stash(form => $form);
|
|
$c->stash(create_flag => 1);
|
|
}
|
|
|
|
1;
|