<%doc>

Example:

 <& elements/process.html,

   ###
   # required
   ###

  'table' => 'tablename',

   #? 'primary_key' => #required when the dbdef doesn't know...???
   #? 'fields' => []   #""

   ###
   # optional
   ###

   'viewall_dir'  => '', #'search' or 'browse', defaults to 'search'
   'viewall_ext'  => 'html', #'cgi' or 'html', defaults to 'html'
   OR
   'redirect'     => 'view/table.cgi?', # value of primary key is appended
                                        # (string or coderef returning a string)
   OR
   'popup_reload' => 'Momentary success message', #will reload parent window

   'error_redirect' => popurl(2).'edit/table.cgi?', #query string appended

   'edit_ext' => 'html', #defaults to 'html', you might want 'cgi' while the
                         #naming is still inconsistent

   'copy_on_empty'  => [ 'old_field_name', 'another_old_field', ... ],

   'clear_on_error' => [ 'form_field1', 'form_field2', ... ],

   ## message will be returned to redirect page as cookie and read by header.html
   ## append =status, =warning, =error to change color of message box.  Default is status
   ## status is green, warning is yellow, and error is red
   'message'        => [ 'My message=status', 'Please restart=warning' ],

                  #pass an arrayref of hashrefs for multiple m2ms or m2names
                  #be certain you incorporate m2m_Common if you see error: param

   'process_m2m' => { 'link_table'   => 'link_table_name',
                      'target_table' => 'target_table_name',
                      #optional (see m2m_Common::process_m2m), if not specified
                      # all CGI params will be passed)
                      'params'       => 
                    },
   'process_m2name' => { 'link_table'   => 'link_table_name',
                         'link_static' => { 'column' => 'value' },
                         'num_col' => 'column', #if column name is different in
                                                #link_table than source_table 
                         'name_col' => 'name_column',
                         'names_list' => [ 'list', 'names' ],
                         
                         'param_style' => 'link_table.value checkboxes',
                         #or#
                         'param_style' => 'name_colN values',


                       },
   'process_o2m' => { 'table' => table_name',
                      'num_col' => 'column', #if column name is different in
                                             #link_table than source_table 
                      'fields' => [qw( fieldname fieldname2 )],
                    },

   'process_locale' => 'fieldname', # update entries in the _msgcat table

   'process_upload' => {
                         'process'  => 'misc/mytable-import.html',
                          # fields to pass to the back end job, besides the 
                          # primary key of the object
                         'fields'   => [qw( fieldname fieldname2 )],
                       },

   'skip_process' => 0, #boolean, if set true, will skip the main table
                        #add/edit processing and only run any linked table
                        #process_ items

   #checks CGI params and whatever else before much else runs
   #return an error string or empty for no error
   'precheck_callback' => sub { my( $cgi ) = @_; },

   #after the new object is created
   #return an error string or empty for no error
   'post_new_object_callback' => sub { my( $cgi, $object ) = @_; },

   #run right before replacing (not run for inserts)
   'edit_callback' => sub { my( $new, $old ) = @_; },

   #after everything's inserted
   'noerror_callback' => sub { my( $cgi, $object ) = @_; },

   #supplies arguments to insert() and replace()
   # for use with tables that are FS::option_Common (among other things)
   'args_callback' => sub { my( $cgi, $object ) = @_; },

   # if no errors after package insert or replace will update services attached to package.
   'update_svc' => sub { my( $cgi, $object ) = @_; },

   'debug' => 1, #turns on debugging output

   #agent virtualization
   'agent_virt'       => 1,
   'agent_null_right' => 'Access Right Name',

   #special bulk insert mode
   'bulk' => 'field',

 &>

</%doc>
%if ( $error ) {
%  ## flatten any array refs so multi selects are sticky on error
%  for my $param ($cgi->param) {
%    if (ref($cgi->param($param)) eq "ARRAY") {
%      $cgi->param($param, (join ",", @{$cgi->param($param)}));
%    }
%  }
%
%  #my $query = $m->scomp('/elements/create_uri_query');
%  #$cgi->redirect("$url?$query");
%  if ( length($cgi->query_string) > 1920 ) { #stupid IE 2083 URL limit
% 
%    my $session = int(rand(4294967296)); #XXX
%    my $pref = new FS::access_user_pref({
%      'usernum'    => $FS::CurrentUser::CurrentUser->usernum,
%      'prefname'   => "redirect$session",
%      'prefvalue'  => $cgi->query_string,
%      'expiration' => time + 3600, #1h?  1m?
%    });
%    my $pref_error = $pref->insert;
%    if ( $pref_error ) {
%      die "FATAL: couldn't even set redirect cookie: $pref_error".
%          " attempting to set redirect$session to ". $cgi->query_string."\n";
%    }
%
<% $cgi->redirect("$error_redirect?redirect=$session") %>
%
%  } else {
%
<% $cgi->redirect("$error_redirect?". $cgi->query_string ) %>
%
%  }
%
% #different ways of handling success
%
%} elsif ( $opt{'process_upload'} and @uploaded_files ) {
%
% # construct a form to pass all the requested fields, the 
%
<& /elements/header.html &>
<form name="UploadForm">
%   my $job_fields = $opt{'process_upload'}{'fields'};
%   foreach my $field ( @$job_fields ) {
  <input type="hidden" name="<% $field %>" value="<% $cgi->param($field) |h %>">
%   }
%   push @$job_fields, 'uploaded_files', $pkey;
%
  <input type="hidden" name="uploaded_files" value="<% join(',', @uploaded_files) %>">
  <input type="hidden" name="<% $pkey %>" value="<% $new->get($pkey) %>">
<& /elements/progress-init.html,
  'UploadForm',
  $job_fields,
  $fsurl . $opt{'process_upload'}{'process'},
  {
    url => $redirect,
    error_url => "$error_redirect?$new_pkey"
  },
&>
<input type="submit" style="display:none">
</form>
<script>
<&| /elements/onload.js &>
process();
</&>
</script>
<& /elements/footer.html &>

% } elsif ( $opt{'progress_init'} ) {
%   # some false laziness with the above
%   my ($form_name, $job_fields) = @{ $opt{'progress_init'} };
<form name="<% $form_name %>">
  <input type="hidden" name="<% $pkey %>" value="<% $new->get($pkey) %>">
%   foreach my $field (@$job_fields) {
%     next if $field eq $pkey;
  <input type="hidden" name="<% $field %>" value="<% $cgi->param($field) |h %>">
%   }
<& /elements/progress-init.html,
  @{ $opt{'progress_init'} }
&>
<input type="submit" style="display:none">
</form>
<script>
<&| /elements/onload.js &>
process();
</&>
</script>
<& /elements/footer.html &>

% } elsif ( $opt{'popup_reload'} ) {

  <% include('/elements/header-popup.html', $opt{'popup_reload'} ) %>

  <SCRIPT TYPE="text/javascript">
    topreload();
  </SCRIPT>

  </BODY>
  </HTML>

%} else {
%  my $cookie;
%  $cookie = CGI::Cookie->new(
%                        -name    => 'freeside_status',
%                        -value   => $messages,
%                        -expires => '+5m',
%                      ) if $messages;
   <% $cgi->redirect( -uri    => $redirect,
                      -cookie => $cookie,
      )
   %>
%}
<%init>

my $me = 'process.html:';

my(%opt) = @_;

my $curuser = $FS::CurrentUser::CurrentUser;

my $error = '';
if ( $opt{'precheck_callback'} ) {
  $error = &{ $opt{'precheck_callback'} }( $cgi );
}

#false laziness w/edit.html
my $table = $opt{'table'};
my $class = "FS::$table";
my $pkey = dbdef->table($table)->primary_key; #? $opt{'primary_key'} || 
my $fields = $opt{'fields'}
             #|| [ grep { $_ ne $pkey } dbdef->table($table)->columns ];
             || [ fields($table) ];

my $old_pkey = $cgi->param($pkey);

my $old = '';
if ( $old_pkey ) {
  $old = qsearchs({
    'table'   => $table,
    'hashref' => { $pkey => $old_pkey },
    'extra_sql' => ( $opt{'agent_virt'}
                       ? ' AND '. $curuser->agentnums_sql(
                                    'null_right' => $opt{'agent_null_right'}
                                  )
                       : ''
                   ),
  });
}

my $bfield = $opt{'bulk'};

my %hash =
  map { my @entry = ( $_ => scalar($cgi->param($_)) );
        $opt{'value_callback'} ? ( $_ => &{ $opt{'value_callback'} }( @entry ))
                               : ( @entry )
      } grep { $_ ne $bfield } @$fields;

my @values = ( 1 );
if ( $bfield ) {
  @values = $cgi->param($bfield);
  #warn join(',', @values);
}

my @uploaded_files;

my $new;
my $new_pkey = '';
foreach my $value ( @values ) {

  if ($opt{'skip_process'}) {

    $new = $old;
    $new_pkey = $old_pkey;

  } else {

    $new = $class->new( \%hash );

    $new->$bfield($value) if $bfield;

    if ($old && exists($opt{'copy_on_empty'})) {
      foreach my $field (@{$opt{'copy_on_empty'}}) {
        $new->set($field, $old->get($field))
          unless scalar($cgi->param($field));
      }
    }

    if ( $opt{'post_new_object_callback'} ) {
      $error ||= &{ $opt{'post_new_object_callback'} }( $cgi, $new );
    }

    if ( $opt{'agent_virt'} ) {

      if ( ! $new->agentnum
           && (    ! $opt{'agent_null_right'}
                || ! $curuser->access_right($opt{'agent_null_right'})
              )
         )
      {

        $error ||= 'Select an agent';

      } else {

        die "illegal agentnum"
          unless $curuser->agentnums_href->{$new->agentnum}
              or $curuser->access_right('View customers of all agents')
              or $opt{'agent_null_right'}
                 && ! $new->agentnum
                 && $curuser->access_right($opt{'agent_null_right'});

      }

    }

    my @args = ();
    if ( !$error && $opt{'args_callback'} ) {
      @args = &{ $opt{'args_callback'} }( $cgi, $new );
    }

    if ( !$error && $opt{'debug'} ) {
      warn "$me updating record in $table table using $class class\n";
      warn Dumper(\%hash);
      warn "with args: \n". Dumper(\@args) if @args;
    }

    if ( !$error ) {
      if ( $old_pkey ) {

        &{ $opt{'edit_callback'} }( $new, $old ) if $opt{'edit_callback'};

        $error = $new->replace($old, @args);
      } else {
        $error = $new->insert(@args);
      }
      $new_pkey = $new->getfield($pkey);
    }

  } #unless $opt{'skip_process'}

  if ( !$error && $opt{'process_m2m'} ) {

    my @process_m2m = ref($opt{'process_m2m'}) eq 'ARRAY'
                        ? @{ $opt{'process_m2m'} }
                        :  ( $opt{'process_m2m'} );

    foreach my $process_m2m (@process_m2m) {

      $process_m2m->{'params'} ||= scalar($cgi->Vars);

      warn "$me processing m2m:\n". Dumper( %$process_m2m )
        if $opt{'debug'};

      $error ||= $new->process_m2m( %$process_m2m );
    }

  }

  if ( !$error && $opt{'process_m2name'} ) {

    my @process_m2name = ref($opt{'process_m2name'}) eq 'ARRAY'
                           ? @{ $opt{'process_m2name'} }
                           :  ( $opt{'process_m2name'} );


    foreach my $process_m2name (@process_m2name) {

      if ( $opt{'debug'} ) {
        warn "$me processing m2name:\n". Dumper( %{ $process_m2name },
                                                 'params' => scalar($cgi->Vars),
                                               );
      }

      $error = $new->process_m2name( %{ $process_m2name },
                                     'params' => scalar($cgi->Vars),
                                   );
    }

  }

  my @process_o2m;
  if ( $opt{'process_o2m'} ) {
    @process_o2m = ref($opt{'process_o2m'}) eq 'ARRAY'
                        ? @{ $opt{'process_o2m'} }
                        :  ( $opt{'process_o2m'} );
  }
  if ( $opt{'process_locale'} ) {
    push @process_o2m,
    {
      'table'  => $table . '_msgcat',
      'fields' => [ 'locale', $opt{'process_locale'} ],
    };
  }

  if ( !$error ) {

    foreach my $process_o2m (@process_o2m) {

      if ( $opt{'debug'} ) {
        warn "$me processing o2m:\n". Dumper( %{ $process_o2m },
                                                 'params' => scalar($cgi->Vars),
                                               );
      }

      $error ||= $new->process_o2m( %{ $process_o2m },
                                     'params' => scalar($cgi->Vars),
                                   );
    }

  }


  if ( !$error and $opt{'process_upload'} ) {
    # mostly duplicates misc/file-upload.html
    $cgi->param('upload_fields') =~ /^([,\w]+)$/
      or $error = "invalid upload_fields";
    my $fields = $1;

    my $dir = $FS::UID::cache_dir. "/cache.". $FS::UID::datasrc;

    foreach my $field (split /,/, $fields) {
      next if $error;
      my $source_name = $cgi->param($field);

      if ( $opt{'debug'} ) {
        warn "$me processing upload: $source_name\n";
      }
      my $fh = $cgi->upload( $field ); # if no file provided, that's fine
      next if !$fh;

      my $suffix = '';
      if ( $source_name =~ /(\.\w+)$/ ) {
        $suffix = lc($1);
      }

      my $sh = File::Temp->new( TEMPLATE => 'upload.XXXXXXXX',
                                SUFFIX   => $suffix,
                                DIR      => $dir,
                                UNLINK   => 0,
                              )
        or $error ||= "can't open temporary file to store upload: $!\n";
      next if $error;
      while(<$fh>) {
        print $sh $_;
      }
      $sh->filename =~ m!.*/([.\w]+)$!;
      push @uploaded_files, "$field:$1";
      if ( $opt{'debug'} ) {
        warn "uploaded as $1\n";
      }
    }
  }

  if ( !$error and $opt{'update_svc'} ) {
    my @args = ();
    @args = &{ $opt{'args_callback'} }( $cgi, $new ) if $opt{'args_callback'};
   $error = &{ $opt{'update_svc'} }( $cgi, $new, @args );
  }

  if ( $error ) {

    if ($opt{'update_svc'}) {
      my $encoded_error = encode_base64($error);
      $cgi->param('error_link', $encoded_error);
    } else {
      $cgi->param('error', $error);
    }

    if ( $opt{'clear_on_error'} && scalar(@{$opt{'clear_on_error'}}) ) {
      foreach my $field (@{$opt{'clear_on_error'}}) {
        $cgi->param($field, '')
      }
    }

  } else {

    if ( $opt{'noerror_callback'} ) {
      &{ $opt{'noerror_callback'} }( $cgi, $new );
    }

  }

  last if $error;

}

if ($class eq "FS::tower" && !$error) {
  foreach my $part_svc_broadband_export ( FS::tower_sector->part_export_svc_broadband ) {
    if ($part_svc_broadband_export and $part_svc_broadband_export->can('export_tower_sector')) {
      my $export_tower = $part_svc_broadband_export->export_tower_sector($new);
      $error = $export_tower->{'error'} if $export_tower;
    }
  }
  if ($error) {
    my $encoded_error = encode_base64($error);
    $cgi->param('error_link', $encoded_error) if $error;

  }
}

# set up redirect URLs

my $redirect;
if ( !$error ) {
  $opt{'redirect'} = &{$opt{'redirect'}}($cgi, $new)
    if ref($opt{'redirect'}) eq 'CODE';

  if ( $opt{'redirect'} ) {

    $redirect = $opt{'redirect'} . $new_pkey;

  } else { 

    my $ext = $opt{'viewall_ext'} || 'html';
    my $viewall_dir = $opt{'viewall_dir'} || 'search';
    my $viewall_url = $opt{'viewall_url'} || ($viewall_dir . "/$table.$ext");

    $redirect = popurl(3) . $viewall_url;
  
  }
}

my $messages = $opt{'message'} ? $opt{'message'} : '';

my $edit_ext = $opt{'edit_ext'} || 'html';
my $error_redirect = $opt{'error_redirect'}
                     || popurl(2)."$table.$edit_ext";
</%init>