projekt kivitendo

package SL::Controller::RequirementSpec;

use strict;

use parent qw(SL::Controller::Base);

use SL::Common ();

use SL::Controller::Helper::ReportGenerator;

use SL::DB::Project;

use SL::DB::ProjectType;

use SL::DB::RequirementSpecRisk;

use SL::DB::RequirementSpecType;

use SL::DB::RequirementSpec;

use SL::Locale::String;

use Rose::Object::MakeMethods::Generic

(

__PACKAGE__->run_before('setup');

title => t8('Title'),

type => t8('Requirement Spec Type'),

status => t8('Requirement Spec Status'),

projectnumber => t8('Project Number'),

mtime => t8('Last modification'),

#

# actions

#

my ($self) = @_;

$self->prepare_report;

sub action_new {

my ($self) = @_;

if ($self->copy_source) {

my ($self) = @_;

$self->render('requirement_spec/_show_basic_settings', { layout => 0 });

}

$self->js

->hide('#basic_settings')

->after('#basic_settings', $html)

my ($self) = @_;

my $html = $self->render('requirement_spec/_project_link_form', { output => 0 }, submit_as => 'ajax');

$self->js

->hide('#basic_settings')

->after('#basic_settings', $html)

my ($self) = @_;

$self->render('requirement_spec/_show_time_and_cost_estimate', { layout => 0 });

}

sub action_ajax_edit_time_and_cost_estimate {

my ($self) = @_;

my $html = $self->render('requirement_spec/_edit_time_and_cost_estimate', { output => 0 });

$first = ($first->children_sorted || [])->[0] if $first;

->after('#time_cost_estimate', $html)

sub action_ajax_save_time_and_cost_estimate {

my ($self) = @_;

$self->requirement_spec->db->do_transaction(sub {

# Make Emacs happy

1;

foreach my $attributes (@{ $::form->{requirement_spec_items} || [] }) {

SL::DB::RequirementSpecItem

->new(id => delete $attributes->{id})

->load

->update_attributes(%{ $attributes });

}

1;

});

$self->js->replaceWith('#time_cost_estimate', $html);

$self->js->remove('#time_cost_estimate_form_container');

if ($self->visible_section) {

$html = $self->render('requirement_spec_item/_section', { output => 0 }, requirement_spec_item => $self->visible_section);

my ($self) = @_;

my ($self) = @_;

}

sub action_update {

my ($self) = @_;

$self->create_or_update;

}

my $self = shift;

my $action = delete($::form->{project_link_action}) || 'keep';

return $self->update_project_link_none_keep_existing($action) if $action =~ m{none|keep|existing};

return $self->update_project_link_new($action) if $action eq 'new';

return $self->update_project_link_create($action) if $action eq 'create';

die "Unknown project link action '$action'";

}

my ($self) = @_;

} else {

flash_later('error', t8('The requirement spec is in use and cannot be deleted.'));

}

$self->redirect_to(action => 'list');

}

my ($self, %params) = @_;

my $versioned_copy = SL::DB::RequirementSpec->new(id => $::form->{versioned_copy_id})->load;

my $version = $versioned_copy->versions->[0];

$version->update_attributes(working_copy_id => $self->requirement_spec->id);

my ($self, %params) = @_;

my $attachment_name = $self->requirement_spec->type->description . ' ' . ($self->requirement_spec->working_copy_id || $self->requirement_spec->id);

$attachment_name .= ' (v' . $self->requirement_spec->version->version_number . ')' if $self->requirement_spec->version;

$attachment_name .= '.pdf';

$attachment_name =~ s/[^\wäöüÄÖÜß \-\+\(\)\[\]\{\}\.,]+/_/g;

$self->send_file($result{file_name}, type => 'application/pdf', name => $attachment_name);

unlink $result{file_name};

}

my ($self, %params) = @_;

my $base_name = $self->requirement_spec->type->template_file_name || 'requirement_spec';

my @pictures = $self->prepare_pictures_for_printing;

my $content = SL::Helper::CreatePDF->create_parsed_file(

template => "${base_name}.html",

format => 'html',

template_type => 'HTML',

variables => {

SELF => $self,

rspec => $self->requirement_spec,

});

# $content is now a scalar of bytes, but $self->render() expects a

# scalar of characters.

$content = Encode::decode('utf-8', $content);

$self->render(\$content, { layout => 0, process => 0 });

}

my ($self) = @_;

where => [ is_template => 1, SL::DB::Manager::RequirementSpec->not_empty_filter ],

sort_by => 'lower(requirement_specs.title)',

) };

}

my ($self, %params) = @_;

my $template = SL::DB::RequirementSpec->new(id => $::form->{template_id})->load;

my %result = $self->requirement_spec->paste_template($template);

$self->render_pasted_text_block($_) for sort { $a->position <=> $b->position } @{ $result{text_blocks} };

$self->render_pasted_section($_) for sort { $a->position <=> $b->position } @{ $result{sections} };

if (@{ $result{sections} } && (($::form->{current_content_type} || 'sections') eq 'sections') && !$::form->{current_content_id}) {

$self->render_first_pasted_section_as_list($result{sections}->[0]);

}

$self->js

->replaceWith('#additional_parts_list_container', $parts_list)

->show( '#additional_parts_list_container')

->remove( '#additional_parts_form_container');

my ($self) = @_;

my %numbers = map { ($_ => 1) } qw(section function_block);

my %formats = map { my $method = "${_}_number_format"; ($_ => $self->requirement_spec->type->$method) } qw(section function_block);

my @items = @{ $self->requirement_spec->sections_sorted };

$self->requirement_spec->db->with_transaction(sub {

while (@items) {

my $item = shift @items;

my $type = $item->parent_id ? 'function_block' : 'section';

$item->update_attributes(fb_number => SL::PrefixedNumber->new(number => $formats{$type} || 0)->set_to($numbers{$type}));

$numbers{$type}++;

unshift @items, @{ $item->children_sorted };

}

$self->requirement_spec->invalidate_version unless $self->requirement_spec->is_template;

1;

});

$self->redirect_to(action => 'show', id => $self->requirement_spec->id);

}

# filters

#

sub setup {

my ($self) = @_;

return 1;

}

sub init_default_project_status { SL::DB::Manager::ProjectStatus->find_by(name => 'planning') }

sub init_default_project_type { SL::DB::ProjectType->new(id => 1)->load }

sub init_project_statuses { SL::DB::Manager::ProjectStatus->get_all_sorted }

sub init_project_types { SL::DB::Manager::ProjectType->get_all_sorted }

sub init_projects { SL::DB::Manager::Project->get_all_sorted }

sub init_risks { SL::DB::Manager::RequirementSpecRisk->get_all_sorted }

sub init_statuses { SL::DB::Manager::RequirementSpecStatus->get_all_sorted }

sub init_customers {

@filter = ( or => [ @filter, id => $self->requirement_spec->customer_id ] ) if $self->requirement_spec && $self->requirement_spec->customer_id;

sub init_requirement_spec {

my ($self) = @_;

$self->copy_source(SL::DB::RequirementSpec->new(id => $::form->{copy_source_id})->load) if $::form->{copy_source_id};

}

my ($self) = @_;

$self->current_text_block_output_position($::form->{current_content_type} !~ m/^(?:text-blocks|tb)-(front|back)/ ? -1 : $1 eq 'front' ? 0 : 1);

}

my ($self) = @_;

return [ grep { $_->includeable } @{ $self->cvar_configs } ];

}

sub init_include_cvars {

my ($self) = @_;

return $::form->{include_cvars} if $::form->{include_cvars} && (ref($::form->{include_cvars}) eq 'HASH');

return { map { ($_->name => ($_->includeable && $_->included_by_default)) } @{ $self->cvar_configs } };

}

# helpers

#

sub create_or_update {

my $self = shift;

if ($is_new) {

$params->{custom_variables} = [];

} else {

$self->requirement_spec->custom_variables;

}

my $value = $cvars->{ $var->config->name };

$value = $::form->parse_amount(\%::myconfig, $value) if $var->config->type eq 'number';

$var->value($value);

}

if (@errors) {

}

if (!$db->do_transaction(sub {

if ($self->copy_source) {

$self->requirement_spec($self->copy_source->create_copy(%{ $params }));

} else {

})) {

$::lxdebug->message(LXDebug::WARN(), "Error: " . $db->error);

$self->requirement_spec->id(undef) if $is_new;

flash('error', @errors);

return $self->render('requirement_spec/new', title => $title);

}

my $basics_html = $self->render('requirement_spec/_show_basic_settings', { output => 0 });

->replaceWith('#basic_settings', $basics_html)

->remove('#basic_settings_form')

sub prepare_report {

my ($self) = @_;

$self->models->disable_plugin('paginated') if $report->{options}{output_format} =~ /^(pdf|csv)$/i;

$self->models->finalize; # for filter laundering

my $callback = $self->models->get_callback;

my @sortable = $is_template ? qw(title mtime) : qw(title customer status type projectnumber mtime);

my %column_defs = (

%column_defs = (

%column_defs,

customer => { raw_data => sub { $self->presenter->customer($_[0]->customer, display => 'table-cell', callback => $callback) },

sub => sub { $_[0]->customer->name } },

projectnumber => { raw_data => sub { $self->presenter->project($_[0]->project, display => 'table-cell', callback => $callback) },

sub => sub { $_[0]->project_id ? $_[0]->project->projectnumber : '' } },

status => { sub => sub { $_[0]->status->description } },

type => { sub => sub { $_[0]->type->description } },

}

if (!$is_template) {

my %cvar_column_defs = map {

my $cfg = $_;

(('cvar_' . $cfg->name) => {

sub => sub { my $var = $_[0]->cvar_by_name($cfg->name); $var ? $var->value_as_text : '' },

text => $cfg->description,

visible => $self->include_cvars->{ $cfg->name } ? 1 : 0,

})

} @{ $self->includeable_cvar_configs };