X-Git-Url: http://wagnertech.de/git?a=blobdiff_plain;f=SL%2FDB%2FRequirementSpec.pm;h=db757e22fbaa3927c3cf79a98369b0df5256baf4;hb=064d15bb6c59188be545d75e895689cdfea04ad6;hp=6a43a2849b94d9a5c808749b4c8f10dc797c0e5c;hpb=c96c4bb2c3561b54ef23330fdb1fa1d528b26fff;p=kivitendo-erp.git

diff --git a/SL/DB/RequirementSpec.pm b/SL/DB/RequirementSpec.pm
index 6a43a2849..db757e22f 100644
--- a/SL/DB/RequirementSpec.pm
+++ b/SL/DB/RequirementSpec.pm
@@ -3,11 +3,13 @@ package SL::DB::RequirementSpec;
 use strict;
 
 use Carp;
+use List::Util qw(max reduce);
 use Rose::DB::Object::Helpers;
 
 use SL::DB::MetaSetup::RequirementSpec;
 use SL::DB::Manager::RequirementSpec;
 use SL::Locale::String;
+use SL::Util qw(_hashify);
 
 __PACKAGE__->meta->add_relationship(
   items            => {
@@ -49,13 +51,17 @@ sub _before_save_initialize_not_null_columns {
   return 1;
 }
 
-sub text_blocks_for_position {
-  my ($self, $output_position) = @_;
+sub text_blocks_sorted {
+  my ($self, %params) = _hashify(1, @_);
 
-  return [ sort { $a->position <=> $b->position } grep { $_->output_position == $output_position } @{ $self->text_blocks } ];
+  my @text_blocks = @{ $self->text_blocks };
+  @text_blocks    = grep { $_->output_position == $params{output_position} } @text_blocks if exists $params{output_position};
+  @text_blocks    = sort { $a->position        <=> $b->position            } @text_blocks;
+
+  return \@text_blocks;
 }
 
-sub sections {
+sub sections_sorted {
   my ($self, @rest) = @_;
 
   croak "This sub is not a writer" if @rest;
@@ -63,12 +69,24 @@ sub sections {
   return [ sort { $a->position <=> $b->position } grep { !$_->parent_id } @{ $self->items } ];
 }
 
+sub sections { &sections_sorted; }
+
 sub displayable_name {
   my ($self) = @_;
 
   return sprintf('%s: "%s"', $self->type->description, $self->title);
 }
 
+sub versioned_copies_sorted {
+  my ($self, %params) = _hashify(1, @_);
+
+  my @copies = @{ $self->versioned_copies };
+  @copies    = grep { $_->version->version_number <=  $params{max_version_number} } @copies if $params{max_version_number};
+  @copies    = sort { $a->version->version_number <=> $b->version->version_number } @copies;
+
+  return \@copies;
+}
+
 sub create_copy {
   my ($self, %params) = @_;
 
@@ -92,17 +110,36 @@ sub _create_copy {
   return $copy;
 }
 
-sub copy_from {
-  my ($self, $source, %attributes) = @_;
+sub _copy_from {
+  my ($self, $params, %attributes) = @_;
+
+  my $source = $params->{source};
 
   croak "Missing parameter 'source'" unless $source;
 
   # Copy attributes.
-  $self->assign_attributes(map({ ($_ => $source->$_) } qw(type_id status_id customer_id project_id title hourly_rate net_sum previous_section_number previous_fb_number is_template)),
-                           %attributes);
+  if (!$params->{paste_template}) {
+    $self->assign_attributes(map({ ($_ => $source->$_) } qw(type_id status_id customer_id project_id title hourly_rate net_sum previous_section_number previous_fb_number is_template)),
+                             %attributes);
+  }
+
+  my %paste_template_result;
 
   # Clone text blocks.
-  $self->text_blocks(map { Rose::DB::Object::Helpers::clone_and_reset($_) } @{ $source->text_blocks });
+  my $clone_text_block = sub {
+    my ($text_block) = @_;
+    my $cloned       = Rose::DB::Object::Helpers::clone_and_reset($text_block);
+    $cloned->position(undef);
+    return $cloned;
+  };
+
+  $paste_template_result{text_blocks} = [ map { $clone_text_block->($_) } @{ $source->text_blocks_sorted } ];
+
+  if (!$params->{paste_template}) {
+    $self->text_blocks($paste_template_result{text_blocks});
+  } else {
+    $self->add_text_blocks($paste_template_result{text_blocks});
+  }
 
   # Save new object -- we need its ID for the items.
   $self->save;
@@ -115,6 +152,7 @@ sub copy_from {
     my ($item) = @_;
     my $cloned = Rose::DB::Object::Helpers::clone_and_reset($item);
     $cloned->requirement_spec_id($self->id);
+    $cloned->position(undef);
     $cloned->children(map { $clone_item->($_) } @{ $item->children });
 
     $id_to_clone{ $item->id } = $cloned;
@@ -122,7 +160,13 @@ sub copy_from {
     return $cloned;
   };
 
-  $self->items(map { $clone_item->($_) } @{ $source->sections });
+  $paste_template_result{sections} = [ map { $clone_item->($_) } @{ $source->sections_sorted } ];
+
+  if (!$params->{paste_template}) {
+    $self->items($paste_template_result{sections});
+  } else {
+    $self->add_items($paste_template_result{sections});
+  }
 
   # Save the items -- need to do that before setting dependencies.
   $self->save;
@@ -133,45 +177,27 @@ sub copy_from {
     $id_to_clone{ $item->id }->update_attributes(dependencies => [ map { $id_to_clone{$_->id} } @{ $item->dependencies } ]);
   }
 
-  $self->update_attributes(%attributes);
+  $self->update_attributes(%attributes) unless $params->{paste_template};
 
-  return $self;
+  return %paste_template_result;
 }
 
-sub delete_items {
-  my ($self) = @_;
+sub copy_from {
+  my ($self, $source, %attributes) = @_;
 
-  my $worker = sub {
-    # First convert all items to sections so that deleting won't
-    # violate foreign key constraints on parent_id.
-    SL::DB::Manager::RequirementSpecItem->update_all(
-      set   => { parent_id => undef, item_type => 'section' },
-      where => [
-        requirement_spec_id => $self->id,
-        '!parent_id'        => undef,
-      ]);
-
-    # Now delete all items in one go.
-    SL::DB::Manager::RequirementSpecItem->delete_all(where => [ requirement_spec_id => $self->id ]);
-
-    # Last clear values in ourself.
-    $self->items([]);
-  };
+  $self->db->with_transaction(sub { $self->_copy_from({ source => $source, paste_template => 0 }, %attributes); });
+}
+
+sub paste_template {
+  my ($self, $template) = @_;
 
-  return $self->db->in_transaction ? $worker->() : $self->db->do_transaction($worker);
+  $self->db->with_transaction(sub { $self->_copy_from({ source => $template, paste_template => 1 }); });
 }
 
-sub previous_version {
+sub highest_version {
   my ($self) = @_;
 
-  my $and    = $self->version_id ? " AND (version_id <> ?)" : "";
-  my $id     = $self->db->dbh->selectrow_array(<<SQL, undef, $self->id, ($self->version_id) x !!$self->version_id);
-   SELECT MAX(id)
-   FROM requirement_specs
-   WHERE (working_copy_id = ?) $and
-SQL
-
-  return $id ? SL::DB::RequirementSpec->new(id => $id)->load : undef;
+  return reduce { $a->version->version_number > $b->version->version_number ? $a : $b } @{ $self->versioned_copies };
 }
 
 sub is_working_copy {
@@ -182,21 +208,17 @@ sub is_working_copy {
 
 sub next_version_number {
   my ($self) = @_;
-  my $max_number = $self->db->dbh->selectrow_array(<<SQL, undef, $self->id);
-    SELECT COALESCE(MAX(ver.version_number), 0)
-    FROM requirement_spec_versions ver
-    JOIN requirement_specs rs ON (rs.version_id = ver.id)
-    WHERE rs.working_copy_id = ?
-SQL
 
-  return $max_number + 1;
+  return max(0, map { $_->version->version_number } @{ $self->versioned_copies }) + 1;
 }
 
 sub create_version {
   my ($self, %attributes) = @_;
 
+  croak "Cannot work on a versioned copy" if $self->working_copy_id;
+
   my ($copy, $version);
-  my $ok = $self->db->do_transaction(sub {
+  my $ok = $self->db->with_transaction(sub {
     delete $attributes{version_number};
 
     $version = SL::DB::RequirementSpecVersion->new(%attributes, version_number => $self->next_version_number)->save;
@@ -213,11 +235,239 @@ sub create_version {
 sub invalidate_version {
   my ($self, %params) = @_;
 
-  $::lxdebug->message(0, "Invalidate version called for id " . $self->id . " version " . $self->version_id);
-  $::lxdebug->show_backtrace(1);
+  croak "Cannot work on a versioned copy" if $self->working_copy_id;
 
   return if !$self->id || !$self->version_id;
   $self->update_attributes(version_id => undef);
 }
 
 1;
+__END__
+
+=pod
+
+=encoding utf8
+
+=head1 NAME
+
+SL::DB::RequirementSpec - RDBO model for requirement specs
+
+=head1 OVERVIEW
+
+The database structure behind requirement specs is a bit involved. The
+important thing is how working copy/versions are handled.
+
+The table contains three important columns: C<id> (which is also the
+primary key), C<working_copy_id> and C<version_id>. C<working_copy_id>
+is a self-referencing column: it can be C<NULL>, but if it isn't then
+it contains another requirement spec C<id>. C<version_id> on the other
+hand references the table C<requirement_spec_versions>.
+
+The design is as follows:
+
+=over 2
+
+=item * The user is always working on a working copy. The working copy
+is identified in the database by having C<working_copy_id> set to
+C<NULL>.
+
+=item * All other entries in this table are referred to as I<versioned
+copies>. A versioned copy is a copy of a working frozen at the moment
+in time it was created. Each versioned copy refers back to the working
+copy it belongs to: each has its C<working_copy_id> set.
+
+=item * Each versioned copy must reference an entry in the table
+C<requirement_spec_versions>. Meaning: for each versioned copy
+C<version_id> must not be C<NULL>.
+
+=item * Directly after creating a versioned copy even the working copy
+itself points to a certain version via its C<version_id> column: to
+the same version that the versioned copy just created points
+to. However, any modification that will be visible to the customer
+(text, positioning etc but not internal things like time/cost
+estimation changes) will cause the working copy to be set to 'no
+version' again. This is achieved via before save hooks in Perl.
+
+=back
+
+=head1 DATABASE TRIGGERS AND CHECKS
+
+Several database triggers and consistency checks exist that manage
+requirement specs, their items and their dependencies. These are
+described here instead of in the individual files for the other RDBO
+models.
+
+=head2 DELETION
+
+When you delete a requirement spec all of its dependencies (items,
+text blocks, versions etc.) are deleted by triggers.
+
+When you delete an item (either a section or a (sub-)function block)
+all of its children will be deleted as well. This will trigger the
+same trigger resulting in a recursive deletion with the bottom-most
+items being deleted first. Their item dependencies are deleted as
+well.
+
+=head2 UPDATING
+
+Whenever you update a requirement spec item a trigger will fire that
+will update the parent's C<time_estimation> column. This also happens
+when an item is deleted or updated.
+
+=head2 CONSISTENCY CHECKS
+
+Several consistency checks are applied to requirement spec items:
+
+=over 2
+
+=item * Column C<requirement_spec_item.item_type> can only contain one of
+the values C<section>, C<function-block> or C<sub-function-block>.
+
+=item * Column C<requirement_spec_item.parent_id> must be C<NULL> if
+C<requirement_spec_item.item_type> is set to C<section> and C<NOT
+NULL> otherwise.
+
+=back
+
+=head1 FUNCTIONS
+
+=over 4
+
+=item C<copy_from $source, %attributes>
+
+Copies everything (basic attributes like type/title/customer, items,
+text blocks, time/cost estimation) save for the versions from the
+other requirement spec object C<$source> into C<$self> and saves
+it. This is done within a transaction.
+
+C<%attributes> are attributes that are assigned to C<$self> after all
+the basic attributes from C<$source> have been assigned.
+
+This function can be used for resetting a working copy to a specific
+version. Example:
+
+ my $requirement_spec = SL::DB::RequirementSpec->new(id => $::form->{id})->load;
+ my $versioned_copy   = SL::DB::RequirementSpec->new(id => $::form->{versioned_copy_id})->load;
+
+  $requirement_spec->copy_from(
+    $versioned_copy,
+    version_id => $versioned_copy->version_id,
+  );
+
+=item C<create_copy>
+
+Creates and returns a copy of C<$self>. The copy is already
+saved. Creating the copy happens within a transaction.
+
+=item C<create_version %attributes>
+
+Prerequisites: C<$self> must be a working copy (see the overview),
+not a versioned copy.
+
+This function creates a new version for C<$self>. This involves
+several steps:
+
+=over 2
+
+=item 1. The next version number is calculated using
+L</next_version_number>.
+
+=item 2. An instance of L<SL::DB::RequirementSpecVersion> is
+created. Its attributes are copied from C<%attributes> save for the
+version number which is taken from step 1.
+
+=item 3. A copy of C<$self> is created with L</create_copy>.
+
+=item 4. The version instance created in step is assigned to the copy
+from step 3.
+
+=item 5. The C<version_id> in C<$self> is set to the copy's ID from
+step 3.
+
+=back
+
+All this is done within a transaction.
+
+In case of success a two-element list is returned consisting of the
+copy & version objects created in steps 3 and 2 respectively. In case
+of a failure an empty list will be returned.
+
+=item C<displayable_name>
+
+Returns a human-readable name for this instance consisting of the type
+and the title.
+
+=item C<highest_version>
+
+Given a working copy C<$self> this function returns the versioned copy
+of C<$self> with the highest version number. If such a version exist
+its instance is returned. Otherwise C<undef> is returned.
+
+This can be used for calculating the difference between the working
+copy and the last version created for it.
+
+=item C<invalidate_version>
+
+Prerequisites: C<$self> must be a working copy (see the overview),
+not a versioned copy.
+
+Sets the C<version_id> field to C<undef> and saves C<$self>.
+
+=item C<is_working_copy>
+
+Returns trueish if C<$self> is a working copy and not a versioned
+copy. The condition for this is that C<working_copy_id> is C<undef>.
+
+=item C<next_version_number>
+
+Calculates and returns the next version number for this requirement
+spec. Version numbers start at 1 and are incremented by one for each
+version created for it, no matter whether or not it has been reverted
+to a previous version since. It boils down to this pseudo-code:
+
+  if (has_never_had_a_version)
+    return 1
+  else
+    return max(version_number for all versions for this requirement spec) + 1
+
+=item C<sections>
+
+An alias for L</sections_sorted>.
+
+=item C<sections_sorted>
+
+Returns an array reference of requirement spec items that do not have
+a parent -- meaning that are sections.
+
+This is not a writer. Use the C<items> relationship for that.
+
+=item C<text_blocks_sorted %params>
+
+Returns an array reference of text blocks sorted by their positional
+column in ascending order. If the C<output_position> parameter is
+given then only the text blocks belonging to that C<output_position>
+are returned.
+
+=item C<validate>
+
+Validate values before saving. Returns list or human-readable error
+messages (if any).
+
+=item C<versioned_copies_sorted %params>
+
+Returns an array reference of versioned copies sorted by their version
+number in ascending order. If the C<max_version_number> parameter is
+given then only the versioned copies whose version number is less than
+or equal to C<max_version_number> are returned.
+
+=back
+
+=head1 BUGS
+
+Nothing here yet.
+
+=head1 AUTHOR
+
+Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
+
+=cut