only limit resultset if there are related rows left
[chaz/p5-DBIx-Class-ResultSet-RecursiveUpdate] / lib / DBIx / Class / ResultSet / RecursiveUpdate.pm
1 use strict;
2 use warnings;
3
4 package DBIx::Class::ResultSet::RecursiveUpdate;
5
6 our $VERSION = '0.013';
7
8 use base qw(DBIx::Class::ResultSet);
9
10 sub recursive_update {
11 my ( $self, $updates, $fixed_fields ) = @_;
12 return
13 DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update(
14 resultset => $self,
15 updates => $updates,
16 fixed_fields => $fixed_fields
17 );
18 }
19
20 package DBIx::Class::ResultSet::RecursiveUpdate::Functions;
21 use Carp;
22 use Scalar::Util qw( blessed );
23 use List::MoreUtils qw/ any /;
24
25 sub recursive_update {
26 my %params = @_;
27 my ( $self, $updates, $fixed_fields, $object, $resolved,
28 $if_not_submitted )
29 = @params{
30 qw/resultset updates fixed_fields object resolved if_not_submitted/};
31 $resolved ||= {};
32
33 # warn 'entering: ' . $self->result_source->from();
34 carp 'fixed fields needs to be an array ref'
35 if $fixed_fields && ref($fixed_fields) ne 'ARRAY';
36 my %fixed_fields;
37 %fixed_fields = map { $_ => 1 } @$fixed_fields if $fixed_fields;
38 if ( blessed($updates) && $updates->isa('DBIx::Class::Row') ) {
39 return $updates;
40 }
41 if ( $updates->{id} ) {
42 $object = $self->find( $updates->{id}, { key => 'primary' } );
43 }
44 my @missing =
45 grep { !exists $updates->{$_} && !exists $fixed_fields{$_} }
46 $self->result_source->primary_columns;
47 if ( !$object && !scalar @missing ) {
48
49 # warn 'finding by: ' . Dumper( $updates ); use Data::Dumper;
50 $object = $self->find( $updates, { key => 'primary' } );
51 }
52 $updates = { %$updates, %$resolved };
53 @missing =
54 grep { !exists $resolved->{$_} } @missing;
55 if ( !$object && !scalar @missing ) {
56
57 # warn 'finding by +resolved: ' . Dumper( $updates ); use Data::Dumper;
58 $object = $self->find( $updates, { key => 'primary' } );
59 }
60 $object ||= $self->new( {} );
61
62 # warn Dumper( $updates ); use Data::Dumper;
63 # direct column accessors
64 my %columns;
65
66 # relations that that should be done before the row is inserted into the
67 # database like belongs_to
68 my %pre_updates;
69
70 # relations that that should be done after the row is inserted into the
71 # database like has_many, might_have and has_one
72 my %post_updates;
73 my %other_methods;
74 my %columns_by_accessor = _get_columns_by_accessor($self);
75
76 # warn 'resolved: ' . Dumper( $resolved );
77 # warn 'updates: ' . Dumper( $updates ); use Data::Dumper;
78 # warn 'columns: ' . Dumper( \%columns_by_accessor );
79 for my $name ( keys %$updates ) {
80 my $source = $self->result_source;
81
82 # columns
83 if ( exists $columns_by_accessor{$name}
84 && !( $source->has_relationship($name)
85 && ref( $updates->{$name} ) ) )
86 {
87
88 #warn "$name is a column\n";
89 $columns{$name} = $updates->{$name};
90 next;
91 }
92
93 # relationships
94 if ( $source->has_relationship($name) ) {
95 if ( _master_relation_cond( $self, $name ) ) {
96
97 #warn "$name is a pre-update rel\n";
98 $pre_updates{$name} = $updates->{$name};
99 next;
100 }
101 else {
102
103 #warn "$name is a post-update rel\n";
104 $post_updates{$name} = $updates->{$name};
105 next;
106 }
107 }
108
109 # many-to-many helper accessors
110 if ( is_m2m( $self, $name ) ) {
111
112 #warn "$name is a many-to-many helper accessor\n";
113 $other_methods{$name} = $updates->{$name};
114 next;
115 }
116
117 # accessors
118 if ( $object->can($name) && not $source->has_relationship($name) ) {
119
120 #warn "$name is an accessor";
121 $other_methods{$name} = $updates->{$name};
122 next;
123 }
124
125 # unknown
126 # TODO: don't throw a warning instead of an exception to give users
127 # time to adapt to the new API
128 $self->throw_exception(
129 "No such column, relationship, many-to-many helper accessor or generic accessor '$name'"
130 );
131 }
132
133 # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper;
134
135 # first update columns and other accessors
136 # so that later related records can be found
137 for my $name ( keys %columns ) {
138
139 #warn "update col $name\n";
140 $object->$name( $columns{$name} );
141 }
142 for my $name ( keys %other_methods ) {
143
144 #warn "update other $name\n";
145 $object->$name( $updates->{$name} );
146 }
147 for my $name ( keys %pre_updates ) {
148
149 #warn "pre_update $name\n";
150 _update_relation( $self, $name, $pre_updates{$name}, $object,
151 $if_not_submitted );
152 }
153
154 # $self->_delete_empty_auto_increment($object);
155 # don't allow insert to recurse to related objects
156 # do the recursion ourselves
157 # $object->{_rel_in_storage} = 1;
158 #warn "CHANGED: " . $object->is_changed . "\n":
159 #warn "IN STOR: " . $object->in_storage . "\n";
160 $object->update_or_insert if $object->is_changed;
161 $object->discard_changes;
162
163 # updating many_to_many
164 for my $name ( keys %$updates ) {
165 next if exists $columns{$name};
166 my $value = $updates->{$name};
167
168 if ( is_m2m( $self, $name ) ) {
169
170 #warn "update m2m $name\n";
171 my ($pk) = _get_pk_for_related( $self, $name );
172 my @rows;
173 my $result_source = $object->$name->result_source;
174 my @updates;
175 if ( !defined $value ) {
176 next;
177 }
178 elsif ( ref $value ) {
179 @updates = @{$value};
180 }
181 else {
182 @updates = ($value);
183 }
184 for my $elem (@updates) {
185 if ( ref $elem ) {
186 push @rows,
187 recursive_update(
188 resultset => $result_source->resultset,
189 updates => $elem
190 );
191 }
192 else {
193 push @rows,
194 $result_source->resultset->find( { $pk => $elem } );
195 }
196 }
197 my $set_meth = 'set_' . $name;
198 $object->$set_meth( \@rows );
199 }
200 }
201 for my $name ( keys %post_updates ) {
202
203 #warn "post_update $name\n";
204 _update_relation( $self, $name, $post_updates{$name}, $object,
205 $if_not_submitted );
206 }
207 return $object;
208 }
209
210 # returns DBIx::Class::ResultSource::column_info as a hash indexed by column accessor || name
211 sub _get_columns_by_accessor {
212 my $self = shift;
213 my $source = $self->result_source;
214 my %columns;
215 for my $name ( $source->columns ) {
216 my $info = $source->column_info($name);
217 $info->{name} = $name;
218 $columns{ $info->{accessor} || $name } = $info;
219 }
220 return %columns;
221 }
222
223 # Arguments: $rs, $name, $updates, $row, $if_not_submitted
224 sub _update_relation {
225 my ( $self, $name, $updates, $object, $if_not_submitted ) = @_;
226
227 # this should never happen because we're checking the paramters passed to
228 # recursive_update, but just to be sure...
229 $object->throw_exception("No such relationship '$name'")
230 unless $object->has_relationship($name);
231
232 #warn "_update_relation $name: OBJ: " . ref($object) . "\n";
233
234 my $info = $object->result_source->relationship_info($name);
235
236 # get a related resultset without a condition
237 my $related_resultset =
238 $self->related_resultset($name)->result_source->resultset;
239 my $resolved;
240 if ( $self->result_source->can('_resolve_condition') ) {
241 $resolved =
242 $self->result_source->_resolve_condition( $info->{cond}, $name,
243 $object );
244 }
245 else {
246 $self->throw_exception(
247 "result_source must support _resolve_condition");
248 }
249
250 # warn "$name resolved: " . Dumper( $resolved ); use Data::Dumper;
251 $resolved = {}
252 if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
253 && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
254 == $resolved;
255
256 my @rel_cols = keys %{ $info->{cond} };
257 map {s/^foreign\.//} @rel_cols;
258
259 #warn "REL_COLS: " . Dumper(@rel_cols); use Data::Dumper;
260 my $rel_col_cnt = scalar @rel_cols;
261
262 # find out if all related columns are nullable
263 my $all_fks_nullable = 1;
264 for my $rel_col (@rel_cols) {
265 $all_fks_nullable = 0
266 unless $related_resultset->result_source->column_info($rel_col)
267 ->{is_nullable};
268 }
269
270 $if_not_submitted = $all_fks_nullable ? 'nullify' : 'delete'
271 unless defined $if_not_submitted;
272
273 #warn "\tNULLABLE: $all_fks_nullable ACTION: $if_not_submitted\n";
274
275 #warn "RELINFO for $name: " . Dumper($info); use Data::Dumper;
276
277 # the only valid datatype for a has_many rels is an arrayref
278 if ( $info->{attrs}{accessor} eq 'multi' ) {
279
280 # handle undef like empty arrayref
281 $updates = []
282 unless defined $updates;
283 $self->throw_exception(
284 "data for has_many relationship '$name' must be an arrayref")
285 unless ref $updates eq 'ARRAY';
286
287 my @updated_objs;
288
289 #warn "\tupdating has_many rel '$name' ($rel_col_cnt columns cols)\n";
290 for my $sub_updates ( @{$updates} ) {
291 my $sub_object = recursive_update(
292 resultset => $related_resultset,
293 updates => $sub_updates,
294 resolved => $resolved
295 );
296
297 push @updated_objs, $sub_object;
298 }
299
300 #warn "\tcreated and updated related rows\n";
301
302 my @related_pks = $related_resultset->result_source->primary_columns;
303
304 my $rs_rel_delist = $object->$name;
305
306 # foreign table has a single pk column
307 if ( scalar @related_pks == 1 ) {
308 $rs_rel_delist = $rs_rel_delist->search_rs(
309 { $related_pks[0] =>
310 { -not_in => [ map ( $_->id, @updated_objs ) ] }
311 }
312 );
313 }
314
315 # foreign table has multiple pk columns
316 else {
317 my @cond;
318 for my $obj (@updated_objs) {
319 my %cond_for_obj;
320 for my $col (@related_pks) {
321 $cond_for_obj{$col} = $obj->get_column($col);
322 }
323 push @cond, \%cond_for_obj;
324 }
325 # only limit resultset if there are related rows left
326 if (scalar @cond) {
327 $rs_rel_delist = $rs_rel_delist->search_rs( { -not => [@cond] } );
328 }
329 }
330
331 #warn "\tCOND: " . Dumper(\%cond);
332 #my $rel_delist_cnt = $rs_rel_delist->count;
333 if ( $if_not_submitted eq 'delete' ) {
334
335 #warn "\tdeleting related rows: $rel_delist_cnt\n";
336 $rs_rel_delist->delete;
337 }
338 elsif ( $if_not_submitted eq 'set_to_null' ) {
339
340 #warn "\tnullifying related rows: $rel_delist_cnt\n";
341 my %update = map { $_ => undef } @rel_cols;
342 $rs_rel_delist->update( \%update );
343 }
344 }
345 elsif ($info->{attrs}{accessor} eq 'single'
346 || $info->{attrs}{accessor} eq 'filter' )
347 {
348
349 #warn "\tupdating rel '$name': $if_not_submitted\n";
350 my $sub_object;
351 if ( ref $updates ) {
352
353 # for might_have relationship
354 if ( $info->{attrs}{accessor} eq 'single'
355 && defined $object->$name )
356 {
357 $sub_object = recursive_update(
358 resultset => $related_resultset,
359 updates => $updates,
360 object => $object->$name
361 );
362 }
363 else {
364 $sub_object = recursive_update(
365 resultset => $related_resultset,
366 updates => $updates,
367 resolved => $resolved
368 );
369 }
370 }
371 else {
372 $sub_object = $related_resultset->find($updates)
373 unless (
374 !$updates
375 && ( exists $info->{attrs}{join_type}
376 && $info->{attrs}{join_type} eq 'LEFT' )
377 );
378 }
379 $object->set_from_related( $name, $sub_object )
380 unless (
381 !$sub_object
382 && !$updates
383 && ( exists $info->{attrs}{join_type}
384 && $info->{attrs}{join_type} eq 'LEFT' )
385 );
386 }
387 else {
388 $self->throw_exception(
389 "recursive_update doesn't now how to handle relationship '$name' with accessor "
390 . $info->{attrs}{accessor} );
391 }
392 }
393
394 sub is_m2m {
395 my ( $self, $relation ) = @_;
396 my $rclass = $self->result_class;
397
398 # DBIx::Class::IntrospectableM2M
399 if ( $rclass->can('_m2m_metadata') ) {
400 return $rclass->_m2m_metadata->{$relation};
401 }
402 my $object = $self->new( {} );
403 if ( $object->can($relation)
404 and !$self->result_source->has_relationship($relation)
405 and $object->can( 'set_' . $relation ) )
406 {
407 return 1;
408 }
409 return;
410 }
411
412 sub get_m2m_source {
413 my ( $self, $relation ) = @_;
414 my $rclass = $self->result_class;
415
416 # DBIx::Class::IntrospectableM2M
417 if ( $rclass->can('_m2m_metadata') ) {
418 return $self->result_source->related_source(
419 $rclass->_m2m_metadata->{$relation}{relation} )
420 ->related_source(
421 $rclass->_m2m_metadata->{$relation}{foreign_relation} );
422 }
423 my $object = $self->new( {} );
424 my $r = $object->$relation;
425 return $r->result_source;
426 }
427
428 sub _delete_empty_auto_increment {
429 my ( $self, $object ) = @_;
430 for my $col ( keys %{ $object->{_column_data} } ) {
431 if ($object->result_source->column_info($col)->{is_auto_increment}
432 and ( !defined $object->{_column_data}{$col}
433 or $object->{_column_data}{$col} eq '' )
434 )
435 {
436 delete $object->{_column_data}{$col};
437 }
438 }
439 }
440
441 sub _get_pk_for_related {
442 my ( $self, $relation ) = @_;
443 my $result_source;
444 if ( $self->result_source->has_relationship($relation) ) {
445 $result_source = $self->result_source->related_source($relation);
446 }
447
448 # many to many case
449 if ( is_m2m( $self, $relation ) ) {
450 $result_source = get_m2m_source( $self, $relation );
451 }
452 return $result_source->primary_columns;
453 }
454
455 # This function determines wheter a relationship should be done before or
456 # after the row is inserted into the database
457 # relationships before: belongs_to
458 # relationships after: has_many, might_have and has_one
459 # true means before, false after
460 sub _master_relation_cond {
461 my ( $self, $name ) = @_;
462
463 my $source = $self->result_source;
464 my $info = $source->relationship_info($name);
465
466 #warn "INFO: " . Dumper($info) . "\n";
467
468 # has_many rels are always after
469 return 0
470 if $info->{attrs}->{accessor} eq 'multi';
471
472 my @foreign_ids = _get_pk_for_related( $self, $name );
473
474 #warn "IDS: " . join(', ', @foreign_ids) . "\n";
475
476 my $cond = $info->{cond};
477
478 sub _inner {
479 my ( $source, $cond, @foreign_ids ) = @_;
480
481 while ( my ( $f_key, $col ) = each %{$cond} ) {
482
483 # might_have is not master
484 $col =~ s/^self\.//;
485 $f_key =~ s/^foreign\.//;
486 if ( $source->column_info($col)->{is_auto_increment} ) {
487 return 0;
488 }
489 if ( any { $_ eq $f_key } @foreign_ids ) {
490 return 1;
491 }
492 }
493 return 0;
494 }
495
496 if ( ref $cond eq 'HASH' ) {
497 return _inner( $source, $cond, @foreign_ids );
498 }
499
500 # arrayref of hashrefs
501 elsif ( ref $cond eq 'ARRAY' ) {
502 for my $new_cond (@$cond) {
503 return _inner( $source, $new_cond, @foreign_ids );
504 }
505 }
506 else {
507 $source->throw_exception(
508 "unhandled relation condition " . ref($cond) );
509 }
510 return;
511 }
512
513 1; # Magic true value required at end of module
514 __END__
515
516 =head1 NAME
517
518 DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive
519
520 =head1 SYNOPSIS
521
522 The functional interface:
523
524 my $new_item = DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update({
525 resultset => $schema->resultset( 'Dvd' ),
526 updates => {
527 id => 1,
528 owned_dvds => [
529 {
530 title => 'One Flew Over the Cuckoo's Nest'
531 }
532 ]
533 }
534 });
535
536
537 As ResultSet subclass:
538
539 __PACKAGE__->load_namespaces( default_resultset_class => '+DBIx::Class::ResultSet::RecursiveUpdate' );
540
541 in the Schema file (see t/lib/DBSchema.pm). Or appriopriate 'use base' in the ResultSet classes.
542
543 Then:
544
545 my $user = $user_rs->recursive_update( {
546 id => 1,
547 owned_dvds => [
548 {
549 title => 'One Flew Over the Cuckoo's Nest'
550 }
551 ]
552 }
553 );
554
555
556 =head1 DESCRIPTION
557
558 This is still experimental. I've added a functional interface so that it can be used
559 in Form Processors and not require modification of the model.
560
561 You can feed the ->create method with a recursive datastructure and have the related records
562 created. Unfortunately you cannot do a similar thing with update_or_create - this module
563 tries to fill that void.
564
565 It is a base class for ResultSets providing just one method: recursive_update
566 which works just like update_or_create but can recursively update or create
567 data objects composed of multiple rows. All rows need to be identified by primary keys
568 - so you need to provide them in the update structure (unless they can be deduced from
569 the parent row - for example when you have a belongs_to relationship).
570 If not all colums comprising the primary key are specified - then a new row will be created,
571 with the expectation that the missing columns will be filled by it (as in the case of auto_increment
572 primary keys).
573
574
575 If the resultset itself stores an assignement for the primary key,
576 like in the case of:
577
578 my $restricted_rs = $user_rs->search( { id => 1 } );
579
580 then you need to inform recursive_update about additional predicate with a second argument:
581
582 my $user = $restricted_rs->recursive_update( {
583 owned_dvds => [
584 {
585 title => 'One Flew Over the Cuckoo's Nest'
586 }
587 ]
588 },
589 [ 'id' ]
590 );
591
592 This will work with a new DBIC release.
593
594 For a many_to_many (pseudo) relation you can supply a list of primary keys
595 from the other table - and it will link the record at hand to those and
596 only those records identified by them. This is convenient for handling web
597 forms with check boxes (or a SELECT box with multiple choice) that let you
598 update such (pseudo) relations.
599
600 For a description how to set up base classes for ResultSets see load_namespaces
601 in DBIx::Class::Schema.
602
603 =head1 DESIGN CHOICES
604
605 Columns and relationships which are excluded from the updates hashref aren't
606 touched at all.
607
608 =head2 Treatment of belongs_to relations
609
610 In case the relationship is included but undefined in the updates hashref,
611 all columns forming the relationship will be set to null.
612 If not all of them are nullable, DBIx::Class will throw an error.
613
614 Updating the relationship:
615
616 my $dvd = $dvd_rs->recursive_update( {
617 id => 1,
618 owner => $user->id,
619 });
620
621 Clearing the relationship (only works if cols are nullable!):
622
623 my $dvd = $dvd_rs->recursive_update( {
624 id => 1,
625 owner => undef,
626 });
627
628 =head2 Treatment of might_have relationships
629
630 In case the relationship is included but undefined in the updates hashref,
631 all columns forming the relationship will be set to null.
632
633 Updating the relationship:
634
635 my $user = $user_rs->recursive_update( {
636 id => 1,
637 address => {
638 street => "101 Main Street",
639 city => "Podunk",
640 state => "New York",
641 }
642 });
643
644 Clearing the relationship:
645
646 my $user = $user_rs->recursive_update( {
647 id => 1,
648 address => undef,
649 });
650
651 =head2 Treatment of has_many relations
652
653 If a relationship key is included in the data structure with a value of undef
654 or an empty array, all existing related rows will be deleted, or their foreign
655 key columns will be set to null.
656
657 The exact behaviour depends on the nullability of the foreign key columns and
658 the value of the "if_not_submitted" parameter. The parameter defaults to
659 undefined which neither nullifies nor deletes.
660
661 When the array contains elements they are updated if they exist, created when
662 not and deleted if not included.
663
664 =head3 All foreign table columns are nullable
665
666 In this case recursive_update defaults to nullifying the foreign columns.
667
668 =head3 Not all foreign table columns are nullable
669
670 In this case recursive_update deletes the foreign rows.
671
672 Updating the relationship:
673
674 Passing ids:
675
676 my $dvd = $dvd_rs->recursive_update( {
677 id => 1,
678 tags => [1, 2],
679 });
680
681 Passing hashrefs:
682
683 my $dvd = $dvd_rs->recursive_update( {
684 id => 1,
685 tags => [
686 {
687 id => 1,
688 file => 'file0'
689 },
690 {
691 id => 2,
692 file => 'file1',
693 },
694 ],
695 });
696
697 Passing objects:
698
699 TODO
700
701 You can even mix them:
702
703 my $dvd = $dvd_rs->recursive_update( {
704 id => 1,
705 tags => [ '2', { id => '3' } ],
706 });
707
708 Clearing the relationship:
709
710 my $dvd = $dvd_rs->recursive_update( {
711 id => 1,
712 tags => undef,
713 });
714
715 This is the same as passing an empty array:
716
717 my $dvd = $dvd_rs->recursive_update( {
718 id => 1,
719 tags => [],
720 });
721
722 =head2 Treatment of many-to-many pseudo relations
723
724 The function gets the information about m2m relations from DBIx::Class::IntrospectableM2M.
725 If it isn't loaded in the ResultSource classes the code relies on the fact that:
726
727 if($object->can($name) and
728 !$object->result_source->has_relationship($name) and
729 $object->can( 'set_' . $name )
730 )
731
732 Then $name must be a many to many pseudo relation.
733 And that in a similarly ugly was I find out what is the ResultSource of
734 objects from that many to many pseudo relation.
735
736
737 =head1 INTERFACE
738
739 =head1 METHODS
740
741 =head2 recursive_update
742
743 The method that does the work here.
744
745 =head2 is_m2m
746
747 $self->is_m2m( 'name ' ) - answers the question if 'name' is a many to many
748 (pseudo) relation on $self.
749
750 =head2 get_m2m_source
751
752 $self->get_m2m_source( 'name' ) - returns the ResultSource linked to by the many
753 to many (pseudo) relation 'name' from $self.
754
755
756 =head1 DIAGNOSTICS
757
758
759 =head1 CONFIGURATION AND ENVIRONMENT
760
761 DBIx::Class::RecursiveUpdate requires no configuration files or environment variables.
762
763 =head1 DEPENDENCIES
764
765 DBIx::Class
766
767 =head1 INCOMPATIBILITIES
768
769 None reported.
770
771
772 =head1 BUGS AND LIMITATIONS
773
774 No bugs have been reported.
775
776 Please report any bugs or feature requests to
777 C<bug-dbix-class-recursiveput@rt.cpan.org>, or through the web interface at
778 L<http://rt.cpan.org>.
779
780
781 =head1 AUTHOR
782
783 Zbigniew Lukasiak C<< <zby@cpan.org> >>
784 Influenced by code by Pedro Melo.
785
786 =head1 LICENCE AND COPYRIGHT
787
788 Copyright (c) 2008, Zbigniew Lukasiak C<< <zby@cpan.org> >>. All rights reserved.
789
790 This module is free software; you can redistribute it and/or
791 modify it under the same terms as Perl itself. See L<perlartistic>.
792
793
794 =head1 DISCLAIMER OF WARRANTY
795
796 BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
797 FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
798 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
799 PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
800 EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
801 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
802 ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH
803 YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
804 NECESSARY SERVICING, REPAIR, OR CORRECTION.
805
806 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
807 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
808 REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE
809 LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL,
810 OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
811 THE SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
812 RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
813 FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
814 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
815 SUCH DAMAGES.
This page took 0.087142 seconds and 4 git commands to generate.