本文整理汇总了Python中utils.json_encode函数的典型用法代码示例。如果您正苦于以下问题:Python json_encode函数的具体用法?Python json_encode怎么用?Python json_encode使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了json_encode函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: _next
def _next():
from models.users import User
token = request.args.get("token")
nsfw = request.args.get("nsfw")
nsfw = nsfw == 'true'
if not token:
return Response(status=403)
user = User.q.filter_by(token=token).first()
if not user:
return Response(status=403)
if not len(user.likes) >= 3:
# IF USER LIKED ARTICLES ARE NOT MORE THAN 5
# RETURN RANDOM
article = user.random_article(nsfw=nsfw)
if not article:
return Response(status=404)
user.visit(article)
return Response(json_encode({'article': article.serialize()}),
mimetype="application/json")
suggested_article = user.suggested_articles(nsfw=nsfw)
if not suggested_article:
article = user.random_article(nsfw=nsfw)
if not article:
return Response(status=404)
user.visit(article)
return Response(json_encode({'article': article.serialize()}),
mimetype="application/json")
visited_article = user.visit(suggested_article)
return Response(json_encode({"article": visited_article.serialize()}),
mimetype="application/json")
示例2: example_websocket_action
def example_websocket_action(self, message):
"""
This `WebSocket <https://developer.mozilla.org/en/WebSockets/WebSockets_reference/WebSocket>`_
action gets exposed to the client automatically by way of the 'WebSocket'
hook at the bottom of this file. The way it works is like this:
.. rubric:: How The WebSocket Hook Works
Whenever a message is received via the `WebSocket <https://developer.mozilla.org/en/WebSockets/WebSockets_reference/WebSocket>`_
Gate One will automatically
decode it into a Python :class:`dict` (only JSON-encoded messages are accepted).
Any and all keys in that :class:`dict` will be assumed to be 'actions' (just
like :js:attr:`GateOne.Net.actions` but on the server) such as this one. If
the incoming key matches a registered action that action will be called
like so::
key(value)
# ...or just:
key() # If the value is None ('null' in JavaScript)
...where *key* is the action and *value* is what will be passed to said
action as an argument. Since Gate One will automatically decode the message
as JSON the *value* will typically be passed to actions as a single :class:`dict`.
You can provide different kinds of arguments of course but be aware that
their ordering is unpredictable so always be sure to either pass *one*
argument to your function (assuming it is a :class:`dict`) or 100% keyword
arguments.
The *self* argument here is automatically assigned by
:class:`TerminalApplication` using the `utils.bind` method.
The typical naming convention for `WebSocket <https://developer.mozilla.org/en/WebSockets/WebSockets_reference/WebSocket>`_
actions is: `<plugin name>_<action>`. Whether or not your action names
match your function names is up to you. All that matters is that you line
up an *action* (string) with a *function* in `hooks['WebSocket']` (see below).
This `WebSocket <https://developer.mozilla.org/en/WebSockets/WebSockets_reference/WebSocket>`_
*action* duplicates the functionality of Gate One's built-in
:func:`gateone.TerminalWebSocket.pong` function. You can see how it is
called by the client (browser) inside of example.js (which is in this
plugin's 'static' dir).
"""
message = {'terminal:example_pong': timestamp}
self.write_message(json_encode(message))
# WebSockets are asynchronous so you can send as many messages as you want
message2 = {'go:notice': 'You just executed the "example_action" action.'}
self.write_message(json_encode(message2))
# Alternatively, you can combine multiple messages/actions into one message:
combined = {
'go:notice': 'Hurray!',
'terminal:bell': {'term': self.current_term}
}
self.write_message(json_encode(combined))
示例3: get_connect_string
def get_connect_string(self, term):
"""
Attached to the (server-side) `terminal:ssh_get_connect_string` WebSocket
action; writes the connection string associated with *term* to the WebSocket
like so::
{'terminal:sshjs_reconnect': {*term*: <connection string>}}
In ssh.js we attach a WebSocket action to 'terminal:sshjs_reconnect'
that assigns the connection string sent by this function to
`GateOne.Terminal.terminals[*term*]['sshConnectString']`.
"""
self.term_log.debug("get_connect_string() term: %s" % term)
session = self.ws.session
session_dir = self.ws.settings['session_dir']
for f in os.listdir(os.path.join(session_dir, session)):
if f.startswith('ssh:'):
terminal, a_colon, connect_string = f[4:].partition(':')
terminal = int(terminal)
if terminal == term:
# TODO: Make it so we don't have to use json_encode below...
message = {
'terminal:sshjs_reconnect': json_encode(
{term: connect_string})
}
self.write_message(message)
return # All done
示例4: send_message
def send_message(fd, event):
"""
Sends the log enumeration result to the client. Necessary because
IOLoop doesn't pass anything other than *fd* and *event* when it handles
file descriptor events.
"""
message = q.get()
#logging.debug('message: %s' % message)
if message == 'complete':
io_loop.remove_handler(fd)
total_bytes = 0
logs_dir = os.path.join(users_dir, "logs")
log_files = os.listdir(logs_dir)
for log in log_files:
log_path = os.path.join(logs_dir, log)
total_bytes += os.stat(log_path).st_size
out_dict = {
'total_logs': len(log_files),
'total_bytes': total_bytes
}
# This signals to the client that we're done
message = {'terminal:logging_logs_complete': out_dict}
self.write_message(message)
return
message = json_encode(message)
if message not in results:
# Keep track of how many/how much
if results:
results.pop() # No need to keep old stuff hanging around
results.append(message)
self.write_message(message)
示例5: get_connect_string
def get_connect_string(self, term):
"""
Writes the connection string associated with *term* to the `WebSocket <https://developer.mozilla.org/en/WebSockets/WebSockets_reference/WebSocket>`_
like so::
{'sshjs_reconnect': {*term*: <connection string>}}
In ssh.js we attach an action (aka handler) to :js:attr:`GateOne.Net.actions`
for 'sshjs_reconnect' messages that attaches the connection string to
`GateOne.Terminal.terminals[*term*]['sshConnectString']`
"""
logging.debug("get_connect_string() term: %s" % term)
session = self.ws.session
session_dir = self.ws.settings['session_dir']
for f in os.listdir(os.path.join(session_dir, session)):
if f.startswith('ssh:'):
terminal, a_colon, connect_string = f[4:].partition(':')
terminal = int(terminal)
if terminal == term:
# TODO: Make it so we don't have to use json_encode below...
message = {
'terminal:sshjs_reconnect': json_encode(
{term: connect_string})
}
self.write_message(message)
return # All done
示例6: save_bookmarks
def save_bookmarks(bookmarks, tws):
"""
Handles saving *bookmarks* for clients.
"""
out_dict = {
'updates': [],
'count': 0,
'errors': []
}
try:
user = tws.get_current_user()['upn']
bookmarks_db = BookmarksDB(tws.settings['user_dir'], user)
updates = bookmarks_db.sync_bookmarks(bookmarks)
out_dict.update({
'updates': updates,
'count': len(bookmarks),
})
out_dict['updateSequenceNum'] = bookmarks_db.get_highest_USN()
except Exception as e:
import traceback
logging.error("Got exception synchronizing bookmarks: %s" % e)
traceback.print_exc(file=sys.stdout)
out_dict['errors'].append(str(e))
if out_dict['errors']:
out_dict['result'] = "Upload completed but errors were encountered."
else:
out_dict['result'] = "Upload successful"
message = {'bookmarks_save_result': out_dict}
tws.write_message(json_encode(message))
示例7: send_message
def send_message(fd, event):
"""
Sends the log enumeration result to the client. Necessary because
IOLoop doesn't pass anything other than *fd* and *event* when it handles
file descriptor events.
"""
io_loop.remove_handler(fd)
message = q.get()
tws.write_message(json_encode(message))
示例8: opt_esc_handler
def opt_esc_handler(text, tws):
"""
Handles text passed from the special optional escape sequance handler. We
use it to tell ssh.js what the SSH connection string is so it can use that
information to duplicate sessions (if the user so desires). For reference,
the specific string which will call this function from a terminal app is:
\x1b]_;ssh|<whatever>\x07
"""
message = {'sshjs_connect': text}
tws.write_message(json_encode(message))
示例9: get
def get(self):
"""Batch delete."""
start = timer.time()
count = int( models.Event.all().count() );
# check if there is something to delete
if count > 0:
db.delete([item for item in models.Event.all()])
if models.Event.all().count() == 0:
self.write( utils.json_encode({
'message':'All events succesfully deleted.',
'load_time': timer.time() - start
}) )
else:
self.write( utils.json_encode({
'message':'Delete failed. Try again.',
'load_time': timer.time() - start
}) )
示例10: rename_tags
def rename_tags(self, renamed_tags):
"""
Handles renaming tags.
"""
user = self.get_current_user()["upn"]
bookmarks_db = BookmarksDB(self.ws.settings["user_dir"], user)
out_dict = {"result": "", "count": 0, "errors": [], "updates": []}
for pair in renamed_tags:
old_name, new_name = pair.split(",")
bookmarks_db.rename_tag(old_name, new_name)
out_dict["count"] += 1
message = {"bookmarks_renamed_tags": out_dict}
self.write_message(json_encode(message))
示例11: get_connect_string
def get_connect_string(term, tws):
"""
Writes the connection string associated with *term* to the websocket like
so:
{'sshjs_reconnect': json_encode({*term*: <connection string>})}
In ssh.js we attach an action (aka handler) to GateOne.Net.actions for
'sshjs_reconnect' messages that attaches the connection string to
GateOne.terminals[*term*]['sshConnectString']
"""
session = tws.session
session_dir = tws.settings['session_dir']
for f in os.listdir(session_dir + '/' + session):
if f.startswith('ssh:'):
terminal, a_colon, connect_string = f[4:].partition(':')
terminal = int(terminal)
if terminal == term:
message = {
'sshjs_reconnect': json_encode({term: connect_string})
}
tws.write_message(json_encode(message))
return # All done
示例12: get
def get(self):
arguments = self.request.arguments()
if 'mac' in arguments:
#GET /clients/:mac
mac_string = self.request.get("mac")
client = get_client_with_mac(utils.mac_string_to_int(mac_string))
if client is None:
client = []
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(utils.json_encode(utils.query_to_array(client), True))
return
#GET /clients/(:t1)(:limit)
pass
示例13: like
def like():
from models.users import User
token = request.args.get("token")
url_id = request.json.get("url")
if not token:
return Response(status=403)
user = User.q.filter_by(token=token).first()
if not user:
return Response(status=403)
from models.users import Article
article = Article.q.fetch_by_id(url_id)
user.like(article)
return Response(json_encode({"message": "liked"}))
示例14: updateserver
def updateserver(request):
server = QateServerInfo()
server.ip = request.POST.get('ip').encode("utf-8")
server.name = request.POST.get('name').encode("utf-8")
server.env = request.POST.get('env').encode("utf-8")
server.pd = request.POST.get('pd').encode("utf-8")
server.role = request.POST.get('role').encode("utf-8")
server.desc = request.POST.get('desc').encode("utf-8")
update_server_info(server)
response = json_encode({
"result": "ok"
})
return HttpResponse(response, content_type="application/json")
示例15: post
def post(self):
"""
Generate randmomized events for a user.
:Arguments:
user_id : int
User id
num_of_events : int
Number of events to generate, max of 100,000 per request
time : str
Time represents ``minutes``, ``days``, ``hours``, ``weeks`` in datetime.timedelta() eg. datetime.timedelta(days=7)
delta : int
Delta is any int value for datetime.timedelta() eg. datetime.timedelta(days=7)
"""
start = timer.time()
time = self.get_argument("time", None)
delta = self.get_argument("delta", 0)
num_of_events = self.get_argument("num_of_events", 0)
user_id = self.get_argument("user_id", 0)
time = str(time) if time in ['minutes','hours','days','weeks'] else None
if not time:
raise tornado.web.HTTPError(404)
user = models.User.all().filter("id =",int(user_id)).get()
if not user:
raise tornado.web.HTTPError(404)
if int(num_of_events) > MAX_NUMBER_OF_EVENTS:
num_of_events = MAX_NUMBER_OF_EVENTS
now = datetime.now()
for i in xrange(1,int(num_of_events)+1):
r = random.randrange(1,int(delta))
e = models.Event(user=user,
name='Event'+str(r),
created=now - utils.timedelta_wrapper(time, int(r)) )
e.put()
d = {}
d["load_time"] = timer.time() - start
d["count"] = models.Event.all().count()
return self.write(utils.json_encode(d))