SL/Presenter/Part.pm

   1 package SL::Presenter::Part;
   2
   3 use strict;
   4
   5 use SL::DB::Part;
   6 use SL::DB::PartClassification;
   7 use SL::Locale::String qw(t8);
   8
   9 use Exporter qw(import);
  10 our @EXPORT = qw(part_picker part select_classification classification_abbreviation type_abbreviation separate_abbreviation typeclass_abbreviation);
  11
  12 use Carp;
  13
  14 sub part {
  15   my ($self, $part, %params) = @_;
  16
  17   $params{display} ||= 'inline';
  18
  19   croak "Unknown display type '$params{display}'" unless $params{display} =~ m/^(?:inline|table-cell)$/;
  20
  21   my $text = join '', (
  22     $params{no_link} ? '' : '<a href="controller.pl?action=Part/edit&part.id=' . $self->escape($part->id) . '">',
  23     $self->escape($part->partnumber),
  24     $params{no_link} ? '' : '</a>',
  25   );
  26   return $self->escaped_text($text);
  27 }
  28
  29 sub part_picker {
  30   my ($self, $name, $value, %params) = @_;
  31
  32   $value = SL::DB::Manager::Part->find_by(id => $value) if $value && !ref $value;
  33   my $id = $params{id} || $self->name_to_id($name);
  34
  35   my @classes = $params{class} ? ($params{class}) : ();
  36   push @classes, 'part_autocomplete';
  37
  38   my $ret =
  39     $self->input_tag($name, (ref $value && $value->can('id') ? $value->id : ''), class => "@classes", type => 'hidden', id => $id,
  40       'data-part-picker-data' => JSON::to_json(\%params),
  41     ) .
  42     $self->input_tag("", ref $value ? $value->displayable_name : '', id => "${id}_name", %params);
  43
  44   $::request->layout->add_javascripts('kivi.Part.js');
  45   $::request->presenter->need_reinit_widgets($id);
  46
  47   $self->html_tag('span', $ret, class => 'part_picker');
  48 }
  49
  50 #
  51 # shortcut for article type
  52 #
  53 sub type_abbreviation {
  54   my ($self, $part_type) = @_;
  55   return $::locale->text('Assembly (typeabbreviation)')   if $part_type eq 'assembly';
  56   return $::locale->text('Part (typeabbreviation)')       if $part_type eq 'part';
  57   return $::locale->text('Assortment (typeabbreviation)') if $part_type eq 'assortment';
  58   return $::locale->text('Service (typeabbreviation)');
  59 }
  60
  61 #
  62 # Translations for Abbreviations:
  63 #
  64 # $::locale->text('None (typeabbreviation)')
  65 # $::locale->text('Purchase (typeabbreviation)')
  66 # $::locale->text('Sales (typeabbreviation)')
  67 # $::locale->text('Merchandise (typeabbreviation)')
  68 # $::locale->text('Production (typeabbreviation)')
  69 #
  70 # and for descriptions
  71 # $::locale->text('Purchase')
  72 # $::locale->text('Sales')
  73 # $::locale->text('Merchandise')
  74 # $::locale->text('Production')
  75
  76 #
  77 # shortcut for article type
  78 #
  79 sub classification_abbreviation {
  80   my ($self, $id) = @_;
  81   SL::DB::Manager::PartClassification->cache_all();
  82   my $obj = SL::DB::PartClassification->load_cached($id);
  83   $obj && $obj->abbreviation ? t8($obj->abbreviation) : '';
  84 }
  85
  86 sub typeclass_abbreviation {
  87   my ($self, $part) = @_;
  88   return '' if !$part || !$part->isa('SL::DB::Part');
  89   return $self->type_abbreviation($part->part_type).$self->classification_abbreviation($part->classification_id);
  90 }
  91
  92 #
  93 # shortcut for article type
  94 #
  95 sub separate_abbreviation {
  96   my ($self, $id) = @_;
  97   SL::DB::Manager::PartClassification->cache_all();
  98   my $obj = SL::DB::PartClassification->load_cached($id);
  99   $obj && $obj->abbreviation && $obj->report_separate ? t8($obj->abbreviation) : '';
 100 }
 101
 102 #
 103 # generate selection tag
 104 #
 105 sub select_classification {
 106   my ($self, $name, %attributes) = @_;
 107   $attributes{value_key} = 'id';
 108   $attributes{title_key} = 'description';
 109   my $collection = SL::DB::Manager::PartClassification->get_all_sorted();
 110   $_->description($::locale->text($_->description)) for @{ $collection };
 111   return $self->select_tag( $name, $collection, %attributes );
 112 }
 113
 114 1;
 115
 116 __END__
 117
 118 =encoding utf-8
 119
 120 =head1 NAME
 121
 122 SL::Presenter::Part - Part related presenter stuff
 123
 124 =head1 SYNOPSIS
 125
 126   # Create an html link for editing/opening a part/service/assembly
 127   my $object = SL::DB::Manager::Part->get_first;
 128   my $html   = SL::Presenter->get->part($object, display => 'inline');
 129
 130 see also L<SL::Presenter>
 131
 132 =head1 DESCRIPTION
 133
 134 see L<SL::Presenter>
 135
 136 =head1 FUNCTIONS
 137
 138 =over 2
 139
 140 =item C<part, $object, %params>
 141
 142 Returns a rendered version (actually an instance of
 143 L<SL::Presenter::EscapedText>) of the part object C<$object>
 144
 145 C<%params> can include:
 146
 147 =over 4
 148
 149 =item * display
 150
 151 Either C<inline> (the default) or C<table-cell>. At the moment both
 152 representations are identical and produce the part's name linked
 153 to the corresponding 'edit' action.
 154
 155 =back
 156
 157 =back
 158
 159 =over 2
 160
 161 =item C<classification_abbreviation $classification_id>
 162
 163 Returns the shortcut of the classification
 164
 165 =back
 166
 167 =over 2
 168
 169 =item C<separate_abbreviation $classification_id>
 170
 171 Returns the shortcut of the classification if the classification has the separate flag set.
 172
 173 =back
 174
 175 =over 2
 176
 177 =item C<select_classification $name,%params>
 178
 179 Returns an HTML select tag with all available classifications.
 180
 181 C<%params> can include:
 182
 183 =over 4
 184
 185 =item * default
 186
 187 The id of the selected item.
 188
 189 =back
 190
 191 =back
 192
 193 =over 2
 194
 195 =item C<part_picker $name, $value, %params>
 196
 197 All-in-one picker widget for parts. The name will be both id and name
 198 of the resulting hidden C<id> input field (but the ID can be
 199 overwritten with C<$params{id}>).
 200
 201 An additional dummy input will be generated which is used to find
 202 parts. For a detailed description of its behaviour, see section
 203 C<PART PICKER SPECIFICATION>.
 204
 205 C<$value> can be a parts id or a C<Rose::DB:Object> instance.
 206
 207 If C<%params> contains C<part_type> only parts of this type will be used
 208 for autocompletion. You may comma separate multiple types as in
 209 C<part,assembly>.
 210
 211 If C<%params> contains C<unit> only parts with this unit will be used
 212 for autocompletion. You may comma separate multiple units as in
 213 C<h,min>.
 214
 215 If C<%params> contains C<convertible_unit> only parts with a unit
 216 that's convertible to unit will be used for autocompletion.
 217
 218 Obsolete parts will by default not be displayed for selection. However they are
 219 accepted as default values and can persist during updates. As with other
 220 selectors though, they are not selectable once overridden.
 221
 222 C<part_picker> will register it's javascript for inclusion in the next header
 223 rendering. If you write a standard controller that only calls C<render> once, it
 224 will just work. In case the header is generated in a different render call
 225 (multiple blocks, ajax, old C<bin/mozilla> style controllers) you need to
 226 include C<kivi.Part.js> yourself.
 227
 228 On pressing <enter> the picker will try to commit the current selection,
 229 resulting in one of the following events, whose corresponding callbacks can be
 230 set in C<params.actions>:
 231
 232 =over 4
 233
 234 =item * C<commit_one>
 235
 236 If exactly one element matches the input, the internal id will be set to this
 237 id, the internal state will be set to C<PICKED> and the C<change> event on the
 238 picker will be fired. Additionally, if C<params> contains C<fat_set_item> a
 239 special event C<set_item:PartPicker> will be fired which is guaranteed to
 240 contain a complete JSON representation of the part.
 241
 242 After that the action C<commit_one> will be executed, which defaults to
 243 clicking a button with id C<update_button> for backward compatibility reasons.
 244
 245 =item * C<commit_many>
 246
 247 If more than one element matches the input, the internal state will be set to
 248 undefined.
 249
 250 After that the action C<commit_one> will be executed, which defaults to
 251 opening a popup dialog for graphical interaction. If C<params> contains
 252 C<multiple> an alternative popup will be opened, allowing multiple items to be
 253 selected. Note however that this requires an additional callback
 254 C<set_multi_items> to work.
 255
 256 =item * C<commit_none>
 257
 258 If no element matches the input, the internal state will be set to undefined.
 259
 260 If an action for C<commit_none> exists, it will be called with the picker
 261 object and current term. The caller can then implement creation of new parts.
 262
 263 =back
 264
 265 =back
 266
 267 =head1 PART PICKER SPECIFICATION
 268
 269 The following list of design goals were applied:
 270
 271 =over 4
 272
 273 =item *
 274
 275 Parts should not be perceived by the user as distinct inputs of partnumber and
 276 description but as a single object
 277
 278 =item *
 279
 280 Easy to use without documentation for novice users
 281
 282 =item *
 283
 284 Fast to use with keyboard for experienced users
 285
 286 =item *
 287
 288 Possible to use without any keyboard interaction for mouse (or touchscreen)
 289 users
 290
 291 =item *
 292
 293 Must not leave the current page in event of ambiguity (cf. current select_item
 294 mechanism)
 295
 296 =item *
 297
 298 Should be useable with hand scanners or similar alternative keyboard devices
 299
 300 =item *
 301
 302 Should not require a feedback/check loop in the common case
 303
 304 =item *
 305
 306 Should not be constrained to exact matches
 307
 308 =item *
 309
 310 Must be atomic
 311
 312 =item *
 313
 314 Action should be overridable
 315
 316 =back
 317
 318 The implementation consists of the following parts which will be referenced later:
 319
 320 =over 4
 321
 322 =item 1
 323
 324 A hidden input (id input), used to hold the id of the selected part. The only
 325 input that gets submitted
 326
 327 =item 2
 328
 329 An input (dummy input) containing a description of the currently selected part,
 330 also used by the user to search for parts
 331
 332 =item 3
 333
 334 A jquery.autocomplete mechanism attached to the dummy field
 335
 336 =item 4
 337
 338 A popup layer for both feedback and input of additional data in case of
 339 ambiguity.
 340
 341 =item 5
 342
 343 An internal status of the part picker, indicating whether id input and dummy
 344 input are consistent. After leaving the dummy input the part picker must
 345 place itself in a consistent status.
 346
 347 =item 6
 348
 349 A clickable icon (popup trigger) attached to the dummy input, which triggers the popup layer.
 350
 351 =back
 352
 353 =head1 BUGS
 354
 355 None atm :)
 356
 357 =head1 AUTHOR
 358
 359 Sven Schöling E<lt>s.schoeling@linet-services.deE<gt>
 360
 361 Martin Helmling E<lt>martin.helmling@opendynamic.deE<gt>
 362
 363 =cut