Submit the form with the given action URL (i.e. the form that submits to
    ``/post/my/data``).
481644
def submit_form_action(self, url):
    
    form = ElementSelector(
        world.browser,
        str('//form[@action="%s"]' % url),
    )
    assert form, \
        "Cannot find a form with action '{}' on the page.".format(url)
    form.submit()
1299608
def formdata_post(url, fields):
    
    content_type, data = formdata_encode(fields)
    req = urllib2.Request(url, data)
    req.add_header('Content-Type', content_type)
    return urllib2.urlopen(req).read()
879761
def response_action(self, request, files_queryset, folders_queryset):
        

        # There can be multiple action forms on the page (at the top
        # and bottom of the change list, for example). Get the action
        # whose button was pushed.
        try:
            action_index = int(request.POST.get('index', 0))
        except ValueError:
            action_index = 0

        # Construct the action form.
        data = request.POST.copy()
        data.pop(helpers.ACTION_CHECKBOX_NAME, None)
        data.pop("index", None)

        # Use the action whose button was pushed
        try:
            data.update({'action': data.getlist('action')[action_index]})
        except IndexError:
            # If we didn't get an action from the chosen form that's invalid
            # POST data, so by deleting action it'll fail the validation check
            # below. So no need to do anything here
            pass

        action_form = self.action_form(data, auto_id=None)
        action_form.fields['action'].choices = self.get_action_choices(request)

        # If the form's valid we can handle the action.
        if action_form.is_valid():
            action = action_form.cleaned_data['action']
            select_across = action_form.cleaned_data['select_across']
            func, name, description = self.get_actions(request)[action]

            # Get the list of selected PKs. If nothing's selected, we can't
            # perform an action on it, so bail. Except we want to perform
            # the action explicitly on all objects.
            selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
            if not selected and not select_across:
                # Reminder that something needs to be selected or nothing
                # will happen
                msg = _("Items must be selected in order to perform "
                        "actions on them. No items have been changed.")
                self.message_user(request, msg)
                return None

            if not select_across:
                selected_files = []
                selected_folders = []

                for pk in selected:
                    if pk[:5] == "file-":
                        selected_files.append(pk[5:])
                    else:
                        selected_folders.append(pk[7:])

                # Perform the action only on the selected objects
                files_queryset = files_queryset.filter(pk__in=selected_files)
                folders_queryset = folders_queryset.filter(
                    pk__in=selected_folders)

            response = func(self, request, files_queryset, folders_queryset)

            # Actions may return an HttpResponse, which will be used as the
            # response from the POST. If not, we'll be a good little HTTP
            # citizen and redirect back to the changelist page.
            if isinstance(response, HttpResponse):
                return response
            else:
                return HttpResponseRedirect(request.get_full_path())
        else:
            msg = _("No action selected.")
            self.message_user(request, msg)
            return None
821216
def post_request(url,args)
      uri = URI.parse(url)
      req = Net::HTTP::Post.new(uri.path)
      req.set_form_data(args)
      request(uri,req)
    end
1044302
def submit(self, url_context=None, utcnow=datetime.datetime.utcnow):
        
        if not url_context:
            url_context = s3_url_context(
                self.endpoint, self.bucket, self.object_name)
        d = self.get_page(
            url_context.get_encoded_url(),
            method=self.action,
            postdata=self.data or b"",
            headers=self.get_headers(utcnow()),
        )

        return d.addErrback(s3_error_wrapper)
685266
def is_form_get(attr, attrs):
    """"""
    res = False
    if attr == "action":
        method = attrs.get_true('method', u'').lower()
        res = method != 'post'
    return res
1318601
def submit(key, type, data, options={})
      @backend.submit(key, type, data, options)
    end
575353
def action_add_url(self):
        """"""
        if not self.env.context.get('active_model'):
            return
        attachment_obj = self.env['ir.attachment']
        for form in self:
            url = parse.urlparse(form.url)
            if not url.scheme:
                url = parse.urlparse('%s%s' % ('http://', form.url))
            for active_id in self.env.context.get('active_ids', []):
                attachment = {
                    'name': form.name,
                    'type': 'url',
                    'url': url.geturl(),
                    'res_id': active_id,
                    'res_model': self.env.context['active_model'],
                }
                attachment_obj.create(attachment)
        return {'type': 'ir.actions.act_close_wizard_and_reload_view'}
322914
@Override
    public void submit(String name, Runnable action) {
        ActionEvent<Void> event = ActionEvent.create(name, action);
        sink.add(event, Channel.BROADCAST);
    }
993192
def action(self, item, action_type, body={}):
        
        uri = "/%s/%s/action" % (self.uri_base, utils.get_id(item))
        action_body = {action_type: body}
        return self.api.method_post(uri, body=action_body)
566741
void submit() {

        // switch to root site
        m_clonedCms.getRequestContext().setSiteRoot("");

        CmsSite site = getSiteFromForm();

        if (m_site == null) {

            //Show report field and hide form fields
            m_report.setVisible(true);
            m_tab.setVisible(false);
            m_ok.setEnabled(false);
            m_ok.setVisible(true);
            //Change cancel caption to close (will not interrupt site creation anymore)
            m_cancel.setVisible(false);
            setOkButtonEnabled();
            m_cancel.setCaption(
                CmsVaadinUtils.getMessageText(org.opencms.workplace.Messages.GUI_DIALOG_BUTTON_CLOSE_0));

            Map<String, String> bundle = getBundleMap();

            boolean createOU = m_fieldCreateOU.isEnabled() & m_fieldCreateOU.getValue().booleanValue();
            CmsCreateSiteThread createThread = new CmsCreateSiteThread(
                m_clonedCms,
                m_manager,
                site,
                m_site,
                m_fieldLoadSiteTemplate.getValue(),
                getFieldTemplate(),
                createOU,
                (String)m_fieldSelectParentOU.getValue(),
                (String)m_fieldSelectOU.getValue(),
                m_os,
                bundle,
                new Runnable() {

                    public void run() {

                }

                });

            CmsReportWidget report = new CmsReportWidget(createThread);

            report.setWidth("100%");
            report.setHeight("350px");

            m_threadReport.addComponent(report);
            createThread.start();
        } else {
            if (!site.getSiteRoot().equals(m_site.getSiteRoot())) {
                m_manager.deleteElements(Collections.singletonList(m_site.getSiteRoot()));
            }
            m_manager.writeElement(site);
            m_manager.closeDialogWindow(true);
        }

    }
1083156
def _sendAction(self, action, attrs=None, chan_vars=None):
        
        self._conn.write("Action: %s\r\n" % action)
        if attrs:
            for (key,val) in attrs:
                self._conn.write("%s: %s\r\n" % (key, val))
        if chan_vars:
            for (key,val) in chan_vars:
                self._conn.write("Variable: %s=%s\r\n" % (key, val))
        self._conn.write("\r\n")
408727
def make_action category, name, defopts, opts = {}
      req = Net::HTTP::Post.new(
        category.nil? ? "#{API_URI.path}/#{name}" : "#{API_URI.path}/#{category}/#{name}"
      )
      form = get_form_data(defopts, opts)
      RegApi2.form_to_be_sent(req.path, form)

      req.set_form_data(form)
      res = http.request(req)

      handle_response(defopts, res)
    end
56702
public function post($uri, $action)
    {
        $uri = $this->buildUri($uri);

        return $this->addResponseType(Route::post($uri, $action));
    }
108047
def post(self, action, data=None, headers=None):
        
        return self.request(make_url(self.endpoint, action), method='POST', data=data,
                            headers=headers)
788525
protected function post_data($action)
  {
      $params = array(
        'PAYMENTACTION' => $action,
        'USER' => $this->options['login'],
        'PWD' => $this->options['password'],
        'VERSION' => $this->version,
        'SIGNATURE' => $this->options['signature'],
        'CURRENCYCODE' => $this->default_currency, );

      $this->post = array_merge($this->post, $params);

      return $this->urlize($this->post);
  }
1276416
def post(url, var):
    """"""
    data = {b[0]: b[1] for b in [a.split("=") for a in var]}
    writeln("Sending data to url", url)
    response = requests.post(url, data=data)
    if response.status_code == 200:
        writeln(response.text)
    else:
        writeln(str(response.status_code), response.reason)