view release on metacpan or  search on metacpan

lib/Catalyst/Model/LDAP/Entry.pm  view on Meta::CPAN

    return $self;
}


sub update {
    my $self = shift;
    my $client = shift || $self->_ldap_client;
    croak 'No LDAP client provided to update' unless $client;

    return $self->next::method( $client, @_ );

 view release on metacpan or  search on metacpan

lib/Catalyst/Model/Riak.pm  view on Meta::CPAN

sub read {
	my($self, $data) = @_;
	return $self->get($data);
}

sub update {
	my($self, $data) = @_;
	
	if ( defined($data->{key}) ) {
		my $object = $self->get({ key => $data->{key} });

 view release on metacpan or  search on metacpan

lib/Catalyst/Model/Search.pm  view on Meta::CPAN

    Catalyst::Exception->throw(
        message => ( ref $self || $self ) . ' does not implement add()'
    );
}

sub update {
    my $self = shift;
    
    Catalyst::Exception->throw(
        message => ( ref $self || $self ) . ' does not implement update()'
    );

 view release on metacpan or  search on metacpan

lib/Catalyst/Model/XML/Feed/Item.pm  view on Meta::CPAN

sub uri {
    my $self = shift;
    return $self->{_uri};
}

sub updated {
    my $self = shift;
    return $self->{_updated};
}

1;

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/AtomPP.pm  view on Meta::CPAN

      my ($self, $c) = @_;

      ...
  }

  sub update_entry : Remote {
      ...
  }

  sub delete_entry : Remote {
      ...

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Authentication.pm  view on Meta::CPAN

}


## this was a short lived method to update user information -
## you should use persist_user instead.
sub update_user_in_session {
    my $c = shift;

    return $c->persist_user;
}

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/AutoCRUD/Controller/AJAX.pm  view on Meta::CPAN

sub list : Chained('base') Args(0) {
    my ($self, $c) = @_;
    $c->forward($c->stash->{cpac}->{g}->{backend}, 'list');
}

sub update : Chained('base') Args(0) {
    my ($self, $c) = @_;
    $c->forward($c->stash->{cpac}->{g}->{backend}, 'update');
}

sub delete : Chained('base') Args(0) {

 view release on metacpan or  search on metacpan

lib/Catalyst/Controller/CRUD.pm  view on Meta::CPAN

 $self->call_trigger( 'update_check', $c, $hash );
 $self->call_trigger( 'update_after', $c, $model );

=cut

sub update {
    my ( $this, $c, $self ) = @_;

    # update already record
    if ( $c->req->param('btn_update') ) {
        my $model = $this->get_model( $c, $self, $c->req->param( $self->setting($c)->{primary} ) );

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Data/Pensieve.pm  view on Meta::CPAN

                foo => [ qw/ foo_id name bar baz / ],
            },
        },
    );
    
    sub update_data :Local :Args(3) {
        my ($self, $c, $pk, $key, $value) = @_;
        
        $c->pensieve->store_revisions(
            some_kinda_data => $pk, {
                $key => $value

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Form/Processor.pm  view on Meta::CPAN

}




sub update_from_form {
    my ( $c, @rest ) = @_;

    my $form = $c->form( @rest ) || return;

    return

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Session/State/Cookie.pm  view on Meta::CPAN

    $c->update_session_cookie( $c->make_session_cookie( $sid ) );

    return $c->maybe::next::method($sid);
}

sub update_session_cookie {
    my ( $c, $updated ) = @_;

    unless ( $c->cookie_is_rejecting( $updated ) ) {
        my $cookie_name = $c->_session_plugin_config->{cookie_name};
        $c->response->cookies->{$cookie_name} = $updated;

 view release on metacpan or  search on metacpan

t/lib/SessionExpiry/Controller/Root.pm  view on Meta::CPAN

    my ($self, $c) = @_;
    $c->session;
    $c->res->output($c->session_expires);
}

sub update_session : Global {
    my ($self, $c) = @_;
    $c->session->{foo} ++;
    $c->res->output($c->session->{foo});
}

 view release on metacpan or  search on metacpan

lib/Catalyst/Plugin/Starch/Cookie.pm  view on Meta::CPAN

This is called automatically by the C<finalize_headers> step in Catalyst.  This method
is provided if you want to override the behavior.

=cut

sub update_session_cookie {
    my ($c) = @_;
    return if !$c->_has_sessionid();
    my $cookie_name = $c->starch->cookie_name();
    $c->res->cookies->{ $cookie_name } = $c->starch_state->cookie_args();
    return;

 view release on metacpan or  search on metacpan

lib/CatalystX/CMS/File.pm  view on Meta::CPAN

B<NOTE:> This is not the same as the SVN::Class->update method!
If you want that method, use the up() alias instead.

=cut

sub update {
    my $self = shift;
    if ( !-s $self ) {
        croak "cannot update an empty file";
    }
    $self->write(@_);

 view release on metacpan or  search on metacpan

lib/CatalystX/CRUD/Object/RDBO.pm  view on Meta::CPAN

Calls delegate->save().

=cut

sub update {
    shift->delegate->save(@_);
}

=head2 delete

 view release on metacpan or  search on metacpan

lib/CatalystX/CRUD/ModelAdapter/DBIC.pm  view on Meta::CPAN

Calls update() on I<dbic_object>.

=cut

sub update {
    my ( $self, $c, $object ) = @_;
    $object->update;
}

=head2 delete( I<context>, I<dbic_object> )

 view release on metacpan or  search on metacpan

lib/CatalystX/CRUD/Controller.pm  view on Meta::CPAN

Alias for save(), just for consistency with the U in CRUD.

=cut

sub update : PathPart Chained('fetch') Args(0) {
    my ( $self, $c ) = @_;
    $self->save($c);
}

=head2 rm

 view release on metacpan or  search on metacpan

lib/CatalystX/ListFramework.pm  view on Meta::CPAN

        $c->stash->{kind} = $kind;
        $c->stash->{id} = $id;  # the update form adds this to the URL
        $c->stash->{template} = 'detail.tt';
    }
    
    sub update :Local {
        my ($self, $c, $kind, $id) = @_;
        my $lf = CatalystX::ListFramework->new($kind, $c);
        $lf->update_from_query({'me.id' => $id}); 
        $c->res->redirect("/listandsearch/$kind");
    }

lib/CatalystX/ListFramework.pm  view on Meta::CPAN

    $c->stash->{box_data} = $box_data;

    return 1;
}

sub update_from_query {  # Update a record. Probably called from an infobox screen
    my ($self, $search) = @_;
    my $c = $self->{c};
    my $rs = $c->model($self->{formdef}->{model})->search($search, {});  # NB: no joins. We'll assume we're looking locally for an id
    my $db_row_obj = $rs->first;
    unless (ref $db_row_obj) { confess "No such object found"; }

 view release on metacpan or  search on metacpan

lib/Catalyst/ActionRole/RequestModel.pm  view on Meta::CPAN

    extends 'Catalyst::Controller';

    sub root :Chained(/root) PathPart('account') CaptureArgs(0)  { }

      sub update :POST Chained('root') PathPart('') Args(0) Does(RequestModel) BodyModel(AccountRequest) {
        my ($self, $c, $request_model) = @_;
        ## Do something with the $request_model
      }

      sub list :GET Chained('root') PathPart('') Args(0) Does(RequestModel) QueryModel(PagingModel) {

lib/Catalyst/ActionRole/RequestModel.pm  view on Meta::CPAN

=head1 DESCRIPTION

Moves creating the request model into the action class execute phase.  The following two actions are essentially
the same in effect:

    sub update :POST Chained('root') PathPart('') Args(0) Does(RequestModel) BodyModel(AccountRequest) {
      my ($self, $c, $request_model) = @_;
      ## Do something with the $request_model
    }

    sub update :POST Chained('root') PathPart('') Args(0) {
      my ($self, $c) = @_;
      my $request_model = $c->model('AccountRequest');
      ## Do something with the $request_model
    }

lib/Catalyst/ActionRole/RequestModel.pm  view on Meta::CPAN

    extends 'Catalyst::Controller';

    sub root :Chained(/root) PathPart('account') CaptureArgs(0)  { }

      sub update :POST Chained('root') PathPart('') Args(0) Does(RequestModel) BodyModel() {
        my ($self, $c, $request_model) = @_;
        ## Do something with the $request_model
      }

      sub list :GET Chained('root') PathPart('') Args(0) Does(RequestModel) QueryModel() {

lib/Catalyst/ActionRole/RequestModel.pm  view on Meta::CPAN

    sub root :Chained(/root) PathPart('account') CaptureArgs(0)  { }

      ## You can use either ~ or ~:: to indicate 'under the current namespace'.

      sub update :POST Chained('root') PathPart('') Args(0) Does(RequestModel) BodyModel(~::RequestBody) {
        my ($self, $c, $request_model) = @_;
        ## Do something with the $request_model
      }

      sub list :GET Chained('root') PathPart('') Args(0) Does(RequestModel) QueryModel(~RequestQuery) {

lib/Catalyst/ActionRole/RequestModel.pm  view on Meta::CPAN

content type to an available request model and throw an L<CatalystX::RequestModel::Utils::InvalidContentType>
exception if none of the available models match.

Example of an action with more than one request model, which will be matched based on request content type.

    sub update :POST Chained('root') PathPart('') Args(0) Does(RequestModel) BodyModel(AccountRequestForm) RequestModel(AccountRequestJSON) {
      my ($self, $c, $request_model) = @_;
      ## Do something with the $request_model
    }

Also, if more than one model matches, you'll get an instance of each matching model.

 view release on metacpan or  search on metacpan

lib/Catmandu/Store/AAT/Bag.pm  view on Meta::CPAN

    Catmandu::NotImplemented->throw(
        message => 'Adding item to store not supported.'
    );
}

sub update {
    my ($self, $id, $data) = @_;
    Catmandu::NotImplemented->throw(
        message => 'Updating item in store not supported.'
    );
}

 view release on metacpan or  search on metacpan

lib/Catmandu/Adlib/API.pm  view on Meta::CPAN

    Catmandu::NotImplemented->throw(
        message => 'Adding items is not supported.'
    );
}

sub update {
    my ($self, $id, $data) = @_;
    Catmandu::NotImplemented->throw(
        message => 'Updating items is not supported.'
    );
}

 view release on metacpan or  search on metacpan

lib/Catmandu/AlephX.pm  view on Meta::CPAN

  when you supply the argument 'marc', an xml document will be created for you,
  and stored in the argument 'xml_full_req'. 'marc' must be an array of arrays.
  When you already supplied 'xml_full_req', it will be overwritten.

=cut
sub update_doc {
  my($self,%args)=@_;

  my $doc_num = $args{doc_num} || $args{doc_number};
  delete $args{$_} for qw(doc_number doc_num);
  $args{doc_num} = $self->format_doc_num($doc_num);

lib/Catmandu/AlephX.pm  view on Meta::CPAN

    say STDERR join("\n",@{$u->errors});
  }

=cut

sub update_item {
  my($self,%args)=@_;
  require Catmandu::AlephX::Op::UpdateItem;
  $args{op} = Catmandu::AlephX::Op::UpdateItem->op();
  my $res = $self->ua->request(\%args,"POST");
  Catmandu::AlephX::Op::UpdateItem->parse($res->content_ref(),\%args);

 view release on metacpan or  search on metacpan

lib/Catmandu/CA/API.pm  view on Meta::CPAN

        lang      => $self->lang
    );
    return $r->put(encode_json($data));
}

sub update {
    my ($self, $id, $data) = @_;
    my $r = Catmandu::CA::API::Request->new(
        url       => $self->url,
        url_query => sprintf('service.php/item/%s/id/%s', $self->model, $id),
        username  => $self->username,

 view release on metacpan or  search on metacpan

lib/Catmandu/Store/FedoraCommons/DC.pm  view on Meta::CPAN

    my $perl  = $self->deserialize($data);
    
    { _id => $pid , %$perl };
}

sub update {
    my ($self,$obj) = @_;
    my $pid = $obj->{_id};

    return undef unless $pid;
    

 view release on metacpan or  search on metacpan

lib/Catmandu/Store/RKD/Bag.pm  view on Meta::CPAN

    Catmandu::NotImplemented->throw(
        message => 'Adding item to store not supported.'
    );
}

sub update {
    my ($self, $id, $data) = @_;
    Catmandu::NotImplemented->throw(
        message => 'Updating item in store not supported.'
    );
}

 view release on metacpan or  search on metacpan

lib/Catmandu/Store/Resolver/Bag.pm  view on Meta::CPAN

    } else {
        $self->pid($response->{'data'}->{'persistentURIs'}->[0]);
    }
}

sub update {
    my ($self, $id, $data) = @_;
    my $response = $self->api->put($id, $data);
    if (defined($response->{'data'}->{'work_pid'})) {
        $self->pid($response->{'data'}->{'work_pid'});
    } else {

 view release on metacpan or  search on metacpan

lib/Catmandu/Store/AAT/Bag.pm  view on Meta::CPAN

    Catmandu::NotImplemented->throw(
        message => 'Adding item to store not supported.'
    );
}

sub update {
    my ($self, $id, $data) = @_;
    Catmandu::NotImplemented->throw(
        message => 'Updating item in store not supported.'
    );
}

 view release on metacpan or  search on metacpan

lib/Catmandu/Store/Datahub/API.pm  view on Meta::CPAN

        });
        return undef;
    }
}

sub update {
    my ($self, $id, $data) = @_;

    if (not defined $id) {
        Catmandu::BadArg->throw(
            'message' => "Record could not be updated. Missing 'id'."

 view release on metacpan or  search on metacpan

lib/Catmandu/Store/REST/Bag.pm  view on Meta::CPAN

sub delete {
    my ($self, $id) = @_;
    return $self->api->delete($id);
}

sub update {
    my ($self, $id, $data) = @_;
    return $self->api->put($id, $data);
}

sub delete_all {

 view release on metacpan or  search on metacpan

lib/Catmandu/Path/simple.pm  view on Meta::CPAN

    ) . "return ${data_var};";

    $self->_eval_sub($body, args => $args, captures => $captures);
}

sub updater {
    my ($self, %opts) = @_;
    my $path     = $self->split_path;
    my $data_var = $self->_generate_var;
    my $captures = {};
    my $args     = [$data_var];