Submit a feedback
Submit a feedback
@param submitFeedbackData Request parameters. (required)
@return ApiSuccessResponse
@throws ApiException If fail to call the API, e.g. server error or cannot deserialize the response body
553386
public ApiSuccessResponse submitFeedback(SubmitFeedbackData submitFeedbackData) throws ApiException {
        ApiResponse<ApiSuccessResponse> resp = submitFeedbackWithHttpInfo(submitFeedbackData);
        return resp.getData();
    }
460434
def submit(opts={})
      response = Hubspot::FormsConnection.submit(SUBMIT_DATA_PATH, params: { form_guid: @guid }, body: opts)
      [204, 302, 200].include?(response.code)
    end
815540
public QueryResponse executeQueryPost(Query query) throws ApiException {
        ApiResponse<QueryResponse> resp = executeQueryPostWithHttpInfo(query);
        return resp.getData();
    }
1323598
public GetFeedbackResponse getFeedback(SesRequest request) {
        InternalRequest internalRequest = this.createRequest("feedback", request, HttpMethodName.GET);
        return this.invokeHttpClient(internalRequest, GetFeedbackResponse.class);
    }
29963
public HTTPResponse submitHTTPRequest(HTTPRequest httpRequest,HTTPClientConfiguration httpClientConfiguration,HTTPMethod httpMethod)
    {
        //create HTTP client
        HttpClient httpClient=this.createHttpClient();
        
        //create URL
        String url=this.createURL(httpRequest,httpClientConfiguration);
        
        //create request
        HttpMethodBase httpMethodClient=this.createMethod(url,httpMethod);
        
        //setup header properties
        this.setupHTTPRequestHeaderProperties(httpRequest,httpMethodClient);

        //set content
        this.setRequestContent(httpRequest,httpMethodClient);

        //get logger
        LoggerManager loggerManager=LoggerManager.getInstance();
        Logger logger=loggerManager.getLogger();
        
        try
        {
            logger.logDebug(new Object[]{"Submitting HTTP request: ",httpMethodClient.getURI()},null);
        }
        catch(URIException exception)
        {
            logger.logDebug(new Object[]{"Submitting HTTP request"},null);
        }

        String responseContent=null;
        int statusCode=-1;
        try
        {
            //submit HTTP request
            statusCode=httpClient.executeMethod(httpMethodClient);

            if(statusCode>=400)
            {
                throw new FaxException("Error while invoking HTTP request, return status code: "+statusCode);
            }
            
            //get response content
            responseContent=httpMethodClient.getResponseBodyAsString();
        }
        catch(FaxException exception)
        {
            throw exception;
        }
        catch(Exception exception)
        {
            throw new FaxException("Error while executing HTTP request.",exception);
        }
        finally
        {
            //release connection
            httpMethodClient.releaseConnection();
        }

        //create HTTP response
        HTTPResponse httpResponse=this.createHTTPResponse(statusCode,responseContent);

        return httpResponse;
    }
592605
def doFeedback(self, item_id, use_comment_template, buyer_id, comment, comment_type, op):
        """"""
        return self.__ask__('doFeedback',
                            feItemId=item_id,
                            feUseCommentTemplate=use_comment_template,
                            feToUserId=buyer_id,
                            feComment=comment,
                            feCommentType=comment_type,
                            feOp=op)['feedbackId']
740099
public ApiSuccessResponse createEmail(CreateData createData) throws ApiException {
        ApiResponse<ApiSuccessResponse> resp = createEmailWithHttpInfo(createData);
        return resp.getData();
    }
818833
public function callbackSubmit()
    {
        $now = date("Y-m-d H:i:s");

        $textfilter = $this->di->get("textfilter");

        $userController = $this->di->get("userController");
        $userdetails = $userController->getOne($this->form->value("sessid"));

        $parses = ["yamlfrontmatter", "shortcode", "markdown", "titlefromheader"];
        $comment = $textfilter->parse($this->form->value("comment"), $parses);
        $comment->frontmatter['title'] = $this->form->value("title");
        $comment = json_encode($comment);

        $comm = new Comm();
        $comm->setDb($this->di->get("db"));
        $comm->find("id", $this->form->value("id"));
        $comm->updated = $now;
        $comm->title = $this->form->value("title");
        $comm->userid = $this->form->value("sessid");
        $comm->comment = $comment;
        $comm->email = $userdetails["email"];
        $comm->save();

        $parentid = (int)$this->form->value("parentid");

        $back = $parentid > 0 ? "/view-one/" . $parentid : "/view-one/" . $this->form->value("id");

        $pagerender = $this->di->get("pageRender");
        $pagerender->redirect("comm" . $back);

        return true;
    }
600824
public ApiResponse<Void> unsubscribeWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = unsubscribeValidateBeforeCall(null, null);
        return apiClient.execute(call);
    }
542577
public void submitAnswer(JSONObject answer, String realm) {
        if (answers == null) {
            answers = new JSONObject();
        }

        try {
            answers.put(realm, answer);
            if (isAnswersFilled()) {
                resendRequest();
            }
        } catch (Throwable t) {
            logger.error("submitAnswer failed with exception: " + t.getLocalizedMessage(), t);
        }
    }
1052558
public void submit(Map<String, String> additionalMetadata) throws IOException {

    if (this.submitted) {
      throw new IOException("MultiTimingEvent has already been submitted.");
    }
    this.submitted = true;

    endStage();

    Map<String, String> finalMetadata = Maps.newHashMap();
    finalMetadata.putAll(additionalMetadata);
    finalMetadata.put(EventSubmitter.EVENT_TYPE, MULTI_TIMING_EVENT);
    for (Stage timing : this.timings) {
      finalMetadata.put(timing.getName(), Long.toString(timing.getDuration()));
    }

    this.submitter.submit(this.name, finalMetadata);
  }
741126
public void showFeedback(String feedbackText) {
        feedbackSpan.setText(feedbackText);
        new MaterialAnimation().transition(Transition.FADEINUP).duration(400).animate(feedbackSpan);
        MaterialLoader.loading(true, getCurrentStep().getDivBody());
        add(divFeedback);
    }
877717
public void updateFeedback(FeedbackItem feedbackItem) {
    if (!TextUtils.isEmpty(feedbackId)) {
      navigation.updateFeedback(feedbackId, feedbackItem.getFeedbackType(), feedbackItem.getDescription(), screenshot);
      sendEventFeedback(feedbackItem);
      feedbackId = null;
      screenshot = null;
    }
  }
623719
def token_submit(self, token_id, json_data={}):
        
        uri = 'tokens/%s' % token_id
        post_body = json.dumps(json_data)

        resp, body = self.post(uri, post_body)
        self.expected_success(200, resp.status)
        body = json.loads(body)
        return rest_client.ResponseBody(resp, body)
1285006
public ApiSuccessResponse stopMonitoring(StopMonitoringData stopMonitoringData) throws ApiException {
        ApiResponse<ApiSuccessResponse> resp = stopMonitoringWithHttpInfo(stopMonitoringData);
        return resp.getData();
    }
718474
public ApiSuccessResponse forward(ForwardData forwardData) throws ApiException {
        ApiResponse<ApiSuccessResponse> resp = forwardWithHttpInfo(forwardData);
        return resp.getData();
    }
1022480
public function doRequest($apiName, array $data, $answerFormat = self::ANSWER_FORMAT_ARRAY, $try_number = 1, $resetTryNodes = true)
    {
        if ($resetTryNodes) {
            $this->resetTryNodes = count(static::$nodeURL);
        }
        $requestId = $this->getNextId();
        $requestData = [
            'jsonrpc' => '2.0',
            'id'      => $requestId,
            'method'  => 'call',
            'params'  => [
                $apiName,
                $data['method'],
                $data['params']
            ]
        ];
        try {
            $curlOptions = [];
            $curlOptions['CURLOPT_CONNECTTIMEOUT'] = $this->wsTimeoutSeconds;
            $answerRaw = $this->curlRequest(
                $this->getCurrentUrl(),
                'post',
                $requestData,
                $curlOptions
            );
            if ($answerRaw['code'] !== 200) {
                throw new \Exception("Curl answer code is '{$answerRaw['code']}' and response '{$answerRaw['response']}'");
            }
            $answer = json_decode($answerRaw['response'], self::ANSWER_FORMAT_ARRAY === $answerFormat);

            if (isset($answer['error'])) {
                throw new \Exception('got error in answer: ' . $answer['error']['code'] . ' ' . $answer['error']['message']);
            }
            //check that answer has the same id or id from previous tries, else it is answer from other request
            if (self::ANSWER_FORMAT_ARRAY === $answerFormat) {
                $answerId = $answer['id'];
            } else { //if (self::ANSWER_FORMAT_OBJECT === $answerFormat) {
                $answerId = $answer->id;
            }
            if ($requestId - $answerId > ($try_number - 1)) {
                throw new \Exception('got answer from old request');
            }


        } catch (\Exception $e) {
            if ($try_number < $this->maxNumberOfTriesToCallApi) {
                //if got WS Exception, try to get answer again
                $answer = $this->doRequest($apiName, $data, $answerFormat, $try_number + 1, false);
            } elseif ($this->resetTryNodes > 1) {
                $this->resetTryNodes = $this->resetTryNodes - 1;
                //if got WS Exception after few ties, connect to reserve node
                $this->setReserveNodeUrlToCurrentUrl();
                $answer = $this->doRequest($apiName, $data, $answerFormat, 1, false);
            } else {
                //if nothing helps
                throw $e;
            }
        }

        return $answer;
    }