Show the response message.
483301
def form_sent(request, slug, template="forms/form_sent.html"):
    
    published = Form.objects.published(for_user=request.user)
    context = {"form": get_object_or_404(published, slug=slug)}
    return render_to_response(template, context, RequestContext(request))
632670
def displayResponse(request, openid_response):
    
    s = getServer(request)

    # Encode the response into something that is renderable.
    try:
        webresponse = s.encodeResponse(openid_response)
    except EncodingError as why:
        # If it couldn't be encoded, display an error.
        text = why.response.encodeToKVForm()
        return render_to_response(
            'server/endpoint.html', {'error': cgi.escape(text)},
            context_instance=RequestContext(request))

    # Construct the appropriate django framework response.
    r = http.HttpResponse(webresponse.body)
    r.status_code = webresponse.code

    for header, value in webresponse.headers.items():
        r[header] = value

    return r
171874
private static void logResponse(StatusUpdate response) {
		String text = response.getStatus();
		String message = String.format(MESSAGE_RESPONSE, text);
		System.out.println(message);
	}
842052
public function display()
    {
        \http_response_code($this->getResponseCode());
        if ($this->contentType) {
            header('Content-Type: ' . $this->contentType);
        }
        //        header('Content-Length: ' . strlen($this->content));
        if ($this->redirection) {
            header('Location: ' . $this->redirection);
        }
        Events::dispatch('beforeResponseSend', array($this));
        session_write_close();
        print $this->content;
        Profiler::dump();
        Events::dispatch('afterResponseSend', array($this));
    }
386694
public function View ()
	{
		
		// If the view is JSON
		
		if ($this->view instanceof \Sonic\View\JSON)
		{
			
			// Display view

			$response = $this->view->display ();
			
		}
		
		// Else call parent method
		
		else
		{
			parent::View ();
		}
		
	}
865870
def create_response(self, message, sign):
        
        def _response(code=200, data=None):
            """
            _response
            """
            resp_msg = message.to_response(code=code, data=data, sign=sign)

            with self._session.session_lock:
                mid = self._conn.publish(topic="/controller",
                                         qos=0, payload=resp_msg.to_dict())
                session = self._session.create(resp_msg, mid=mid, age=10)
            logging.debug("sending response as mid: %s" % mid)
            return self._wait_published(session, no_response=True)
        return _response
551190
function(response) {
            message      = response.data;
            users        = $module.data('users');
            loggedInUser = $module.data('user');
            if(users[ message.userID] !== undefined) {
              // logged in user's messages already pushed instantly
              if(loggedInUser === undefined || loggedInUser.id != message.userID) {
                message.user = users[ message.userID ];
                module.message.display(message);
              }
            }
          }
271002
async def listen(self):
        ""
        if self.subscribed:
            return self.handle_message(await self.parse_response(block=True))
421845
def show_messages(self):
        """"""
        string = self.header
        if self.static_message is not None:
            string += self.static_message.to_html()

        for message in self.dynamic_messages:
            string += message.to_html()

        string += self.footer
        print(string)
        self.setHtml(string)
777437
def on_response(self, msg: Dict[str, str]) -> None:
        """"""
        response = msg.get('data', False)
        if response:
            task = self.__tasks.pop(msg.get('reqid'), False)
            if task and not task.cancelled() and not task.done():
                task.set_result(msg.get('data'))
1115093
def response_message(cls, result, request_id):
        ''''''
        if isinstance(result, CodeMessageError):
            payload = cls.error_payload(result, request_id)
        else:
            payload = cls.response_payload(result, request_id)
        return cls.encode_payload(payload)
325572
def QueueResponse(self, message, blocking=True):
    """"""
    self._out_queue.Put(message, block=blocking)
310974
function show_message($message, $type = 'notice', $vars = null, $override = true, $timeout = 0)
    {
        if ($this->app->text_exists($message)) {
            $message = $this->app->gettext(array('name' => $message, 'vars' => $vars));
        }

        printf("[%s] %s\n", strtoupper($type), $message);
    }
478990
async def _response_handler(self):
        """"""
        if self.debug is True:
            if self.debug is True:
                print("listenning response!")
        while True:
            try:
                res = await self.reader.readuntil(self.SEPARATOR)
            except:
                raise
            else:
                response = self.decoder(res)
                self._status_code_check(response)
228559
def message(msg):
    """"""
    v = MaltegoMessage(message=msg).render(encoding='utf-8')
    return Response(v, status=200, mimetype='text/xml')
1260176
def render_response(self, **kwargs):
        """"""
        from flask import Response
        return Response(self.render(**kwargs), mimetype='image/svg+xml')
467386
public static void makeResponse(HttpResponse response, String msg, int status) {
        response.setStatusCode(status);
        makeStringResponse(response, msg);
    }