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) = @_;

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) = @_;

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 $temp_dir = File::Temp->newdir(

"kivitendo-print-XXXXXX",

DIR => SL::System::Process::exe_dir() . "/" . $::lx_office_conf{paths}->{userspath},

CLEANUP => !$keep_temp_files,

);

my %result = SL::Template::LaTeX->parse_and_create_pdf("${base_name}.tex", SELF => $self, rspec => $self->requirement_spec, userspath => $temp_dir->dirname);

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) = @_;

ckeditor/ckeditor ckeditor/adapters/jquery);

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) = @_;

}

# helpers

#

sub create_or_update {

my $is_new = !$self->requirement_spec->id;

my $cvars = delete($::form->{cvars}) || { };

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) {

}

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

} else {

# If the current requirement spec has versions and the

# customer's been changed, then the customer of all the versions

# has to be changed, too.

if ( !$is_new

&& !$self->requirement_spec->is_template

&& ($previous_customer_id != $self->requirement_spec->customer_id)) {

SL::DB::Manager::RequirementSpec->update_all(

set => { customer_id => $self->requirement_spec->customer_id },

where => [ working_copy_id => $self->requirement_spec->id ],

);

}

$::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,