def member_search_json_view(context, request):
try:
# Query parameter shall be 'term'.
prefix = request.params['term']
except UnicodeDecodeError:
# not utf8, just return empty list since tags can't have these chars
result = JSONEncoder().encode([])
return Response(result, content_type="application/x-json")
# case insensitive
prefix = prefix.lower()
community = find_interface(context, ICommunity)
member_names = community.member_names
moderator_names = community.moderator_names
community_member_names = member_names.union(moderator_names)
query = dict(
member_name='%s*' % prefix,
sort_index='title',
limit=20,
)
searcher = ICatalogSearch(context)
try:
total, docids, resolver = searcher(**query)
profiles = filter(None, map(resolver, docids))
records = [
dict(
value=profile.__name__,
label=profile.title,
) for profile in profiles
if profile.__name__ not in community_member_names
and profile.security_state != 'inactive'
]
except ParseError:
records = []
result = JSONEncoder().encode(records)
return Response(result, content_type="application/x-json")
def jquery_tag_search_view(context, request):
tag_query_tool = getMultiAdapter((context, request), ITagQuery)
try:
prefix = request.params['val']
except UnicodeDecodeError:
# not utf8, just return empty list since tags can't have these chars
result = JSONEncoder().encode([])
return Response(result, content_type="application/x-json")
# case insensitive
prefix = prefix.lower()
values = tag_query_tool.tags_with_prefix(prefix)
records = [dict(text=value) for value in values]
result = JSONEncoder().encode(records)
return Response(result, content_type="application/x-json")
def redis_cluster_fosc_add(fid,
isp,
peer_id,
version,
nat_type,
public_ip,
public_port,
private_ip,
private_port,
stun_ip,
cppc=1,
ppc=304):
"""
在FOSC中set value，若非必要，尽量使用cache_report或control_report请求汇报，由ts-go服务器写入FOSC
目前服务器维护seed list不只单单使用FOSC，还涉及到LFC，LFCacheManageZset
"""
key = "{FOSC_" + str(fid) + "_" + str(isp) + "}"
value = {
"peer_id": str(peer_id),
"version": str(version),
"natType": int(nat_type),
"publicIP": str(public_ip),
"publicPort": int(public_port),
"privateIP": str(private_ip),
"privatePort": int(private_port),
"stunIP": str(stun_ip),
"cppc": int(cppc),
"ppc": int(ppc)
}
# 将dict转成json格式
value = JSONEncoder().encode(value)
rc.sadd(key, value)
def jquery_member_search_view(context, request):
prefix = request.params['val'].lower()
community = find_interface(context, ICommunity)
member_names = community.member_names
moderator_names = community.moderator_names
community_member_names = member_names.union(moderator_names)
query = dict(
member_name='%s*' % prefix,
sort_index='title',
limit=20,
)
searcher = ICatalogSearch(context)
try:
total, docids, resolver = searcher(**query)
profiles = filter(None, map(resolver, docids))
records = [
dict(
id=profile.__name__,
text=profile.title,
) for profile in profiles
if profile.__name__ not in community_member_names
and profile.security_state != 'inactive'
]
except ParseError:
records = []
result = JSONEncoder().encode(records)
return Response(result, content_type="application/x-json")
def jquery_tag_del_view(context, request):
value = request.params['val'].strip()
value = value.decode('utf')
del_tags(context, request, [value])
status = {}
result = JSONEncoder().encode(status)
return Response(result, content_type="application/x-json")
def set_allow_weight(isp, pro, lp_ip_list):
rc = redis.StrictRedis(host=REDIS_SINGLE_HOST, port=REDIS_PORT, db=0)
key = "ALLOW_WEIGHT-" + str(isp) + "_" + str(pro)
value = lp_ip_list
# 将dict转成json格式
value = JSONEncoder().encode(value)
rc.set(key, value)
def convert_MediaElchNFO_to_JSON(filename):
tree = etree.parse(filename)
root = tree.getroot()
#dumpLeaf(root)
movie = {}
encodeLeaf(root, movie)
return JSONEncoder().encode(movie)
def readjsonstructure(self,
project_id,
visibility_filter=StaticFiltersFactory.FULL_VIEW,
first_level=None,
second_level=None,
filter_value=None):
"""
AJAX exposed method.
Will return the complete JSON for Project's structure, or filtered tree
(filter only Relevant entities or Burst only Data).
"""
if first_level is None or second_level is None:
first_level, second_level = self.get_project_structure_grouping()
else:
self.set_project_structure_grouping(first_level, second_level)
selected_filter = StaticFiltersFactory.build_datatype_filters(
single_filter=visibility_filter)
if project_id == 'undefined':
project_id = common.get_current_project().id
project = self.project_service.find_project(project_id)
json_structure = self.project_service.get_project_structure(
project, selected_filter, first_level, second_level, filter_value)
# This JSON encoding is necessary, otherwise we will get an error
# from JSTree library while trying to load with AJAX
# the content of the tree.
encoder = JSONEncoder()
return encoder.iterencode(json_structure)
def tag_search_json_view(context, request):
tag_query_tool = getMultiAdapter((context, request), ITagQuery)
try:
# Query parameter shall be 'term'.
prefix = request.params['term']
except UnicodeDecodeError:
# not utf8, just return empty list since tags can't have these chars
result = JSONEncoder().encode([])
return Response(result, content_type="application/x-json")
# case insensitive
prefix = prefix.lower()
values = tag_query_tool.tags_with_prefix(prefix)
# uniterize
values = list(values)
# The return payload simply expects the list of labels.
result = JSONEncoder().encode(values)
return Response(result, content_type="application/x-json")
def serialize(object, human=False):
if human:
indent = 2
sort_keys = True
else:
indent = None
sort_keys = False
return JSONEncoder(indent=indent,
sort_keys=sort_keys).encode(object)
def save_node_set(self, name, nodes):
name = unquote(name)
nodes = unquote(nodes)
file_name = "nodes-sets.json"
data = JSONDecoder().decode(file(file_name).read())
data[name] = nodes
open(file_name, "w").write(
JSONEncoder(indent=4,sort_keys=1).encode(data))
return {"name": name}
def __init__(self, source, options={}, attrs={}):
"""source can be a list containing the autocomplete values or a
string containing the url used for the XHR request. """
self.options = {'source': source, 'minLength': '2', 'max': '64'}
self.attrs = {'autocomplete': 'off'}
if len(options) > 0:
self.options = JSONEncoder().encode(options)
self.attrs.update(attrs)
def getFinal(self, receiver):
encrypted = self.__getCipherText()
# encrypted = JSONEncoder().encode(encrypted)
encryptedRSA = PgpHandler.RSAencrypt(self.publicKey,
encrypted["AESkey"])
obj = {
"to": receiver,
"cipher": encrypted["cipher"],
"AESEncryptedKey": encryptedRSA
}
return JSONEncoder(separators=(',', ':')).encode(obj)
def test_raises_bad_request_when_rpc_params_are_invalid(self):
from simplejson import JSONEncoder
from pyramid.httpexceptions import HTTPBadRequest
rpc_request = {'method': 'checkWords', 'params': ['en']}
json = JSONEncoder().encode(rpc_request)
request = testing.DummyRequest(method='POST',
body=json,
content_type='application/x-json')
self.assertRaises(HTTPBadRequest, self._callFUT, request)
def jquery_tag_add_view(context, request):
value = request.params['val'].strip()
value = value.decode('utf')
add_tags(context, request, [value])
status = {}
# check for valid characters
if not _validate_tag(value):
# This will signal an error for the client.
status['error'] = 'Adding tag failed, it contains illegal characters.'
result = JSONEncoder().encode(status)
return Response(result, content_type="application/x-json")
def redis_single_zadd_pgpfc(user_id,
task_count,
file_id,
fsize,
psize,
ppc,
operation,
src,
priority,
server_host=None,
server_port=None):
"""
推送到某个user id的task列表
:param user_id:
:param task_count: 任务份数
:param file_id:
:param fsize:
:param psize:
:param ppc:
:param operation:
:param src:
:param priority:
:param server_host:
:param server_port:
:return:
"""
key = "PGPFC_" + str(user_id)
if operation == "download":
value = {
"file_id": str(file_id),
"fsize": int(fsize),
"psize": int(psize),
"ppc": int(ppc),
"operation": str(operation),
"src": src,
"priority": int(priority)
}
if server_host is not None and server_port is not None:
value["server"] = str(server_host)
value["port"] = int(server_port)
elif operation == "delete":
value = {
"file_id": str(file_id),
"psize": int(psize),
"ppc": int(ppc),
"operation": str(operation),
"src": src,
"priority": int(priority)
}
else:
raise
# 将dict转成json格式
value = JSONEncoder().encode(value)
rc.zadd(key, task_count, value)
def lpush_rrpc_leave_lf(redis_single_host, redis_single_port, stun_ip, file_id, peer_ids):
rc = redis.StrictRedis(host=redis_single_host, port=redis_single_port, db=0)
RRPC_KEY = "RRPC_" + str(stun_ip)
if type(peer_ids) is not list: peer_ids = [peer_ids]
value = {
"cmd": "leave_lf",
"file_id": str(file_id),
"peer_ids": peer_ids
}
# 将dict转成json格式
value = JSONEncoder().encode(value)
rc.lpush(RRPC_KEY, value)
def convert_to_script(data, var_name='_karl_client_data'):
if data:
##print data
result = JSONEncoder().encode(data)
script = dedent("""\
<script type="text/javascript">
window.%s = %s;
</script>""" % (var_name, result))
else:
# no data, no script.
script = ''
return script
def test_get_project_structure(self):
dt_factory = datatypes_factory.DatatypesFactory()
self._create_datatypes(dt_factory, 3)
node_json = self.project_service.get_project_structure(
dt_factory.project, None, 'Data_State', 'Data_Subject', None)
encoder = JSONEncoder()
encoder.iterencode(node_json)
# No exceptions were raised so far.
project_dts = dao.get_datatypes_for_project(dt_factory.project.id)
for dt in project_dts:
self.assertTrue(
dt.gid in node_json,
"Should have all datatypes present in resulting json.")
def test_renders_error_response_for_unsupported_language(self):
from simplejson import JSONEncoder
rpc_request = {
'id': None,
'method': 'checkWords',
'params': ['za', ['foo', 'bar']]
}
json = JSONEncoder().encode(rpc_request)
request = testing.DummyRequest(method='POST', body=json)
data = self._callFUT(testing.DummyModel(), request)
self.assertEquals(data['id'], None)
self.assertEquals(data['result'], [])
self.assertEquals(data['error'], 'Language is not supported')
def test_renders_suggestions_for_getSuggestions_request(self):
from simplejson import JSONEncoder
rpc_request = {
'id': None,
'method': 'getSuggestions',
'params': ['en', 'foo']
}
json = JSONEncoder().encode(rpc_request)
request = testing.DummyRequest(method='POST', body=json)
data = self._callFUT(testing.DummyModel(), request)
self.assertEquals(data['id'], None)
self.assertEquals(data['result'], ['foo', 'foo', 'foo'])
self.assertEquals(data['error'], None)
def test_parses_valid_getSuggestions_request(self):
from simplejson import JSONEncoder
rpc_request = {'method': 'getSuggestions', 'params': ['en', 'hello']}
json = JSONEncoder().encode(rpc_request)
request = testing.DummyRequest(method='POST',
body=json,
content_type='application/x-json')
methodcall, lang, words = self._callFUT(request)
self.assertEqual(methodcall, 'getSuggestions')
self.assertEqual(lang, 'en')
self.assertEqual(words, ['hello'])
def test_renders_misspelled_words_for_checkWords_request(self):
from simplejson import JSONEncoder
rpc_request = {
'id': None,
'method': 'checkWords',
'params': ['en', ['foo', 'bar']]
}
json = JSONEncoder().encode(rpc_request)
request = testing.DummyRequest(method='POST', body=json)
data = self._callFUT(testing.DummyModel(), request)
self.assertEquals(data['id'], None)
self.assertEquals(data['result'], ['foo', 'bar'])
self.assertEquals(data['error'], None)
def jquery_grid_view(context, request):
sort_on = request.params.get('sortColumn', None)
reverse = request.params.get('sortDirection') == 'desc'
payload = get_grid_data(
context,
request,
start=int(request.params.get('start', '0')),
limit=int(request.params.get('limit', '12')),
sort_on=sort_on,
reverse=reverse,
)
del payload['batch']
del payload['slickgrid_info']
result = JSONEncoder().encode(payload)
return Response(result, content_type="application/x-json")
def __init__(self,
charset: str = "utf-8",
headers: Union[Headers, HeadersList] = None,
status_code: int = HTTP_OK,
**kwargs):
if not JSON_GENERATOR:
# pyl-int: disable=super-init-not-called
raise NotImplementedError(
"JSONGeneratorResponse need simplejson module")
mime_type = "application/json"
if charset:
mime_type += "; charset=" + charset
generator = JSONEncoder( # type: ignore
iterable_as_array=True).iterencode(kwargs) # type: ignore
super().__init__(generator, mime_type, headers, status_code)
class Handler(Reqs, SimpleHTTPRequestHandler):
def do_GET(self):
path, args = self.parse_req()
if not hasattr(self, path):
SimpleHTTPRequestHandler.do_GET(self)
return
try:
res = eval("self." + path, {"self":self}, {})(**args)
except Exception, e:
self.error(e.message)
return
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
self.wfile.write(JSONEncoder().encode(res))
def add_json(self, uuid, host, token, smolt_protocol):
pub_uuid = None
if not at_final_server():
final_token = self.new_token(uuid)
host_dict = simplejson.loads(host)
host_dict_excerpt = self._impl.data_for_next_hop(host_dict)
json_host_excerpt = JSONEncoder(
indent=2, sort_keys=True).encode(host_dict_excerpt)
response_dict = self.forward('add_json',
uuid=uuid,
host=json_host_excerpt,
token=final_token,
smolt_protocol=smolt_protocol)
pub_uuid = response_dict['pub_uuid']
# TODO handle passwords?
response_dict = self._impl.add_json_plus_pub_uuid(
uuid, pub_uuid, host, token, smolt_protocol)
return response_dict
def cluster_setex_pnic(ttl, peer_id, sdk_version, nat_type, public_ip, public_port, private_ip, private_port,
province_id, isp_id, city_id, stun_ip, country="CN"):
"""
在redis中写入某节点的PNIC信息，并设定其有效存活时间
:param ttl: expire time
:param peer_id:
:param sdk_version:
:param nat_type:
:param public_ip:
:param public_port:
:param private_ip:
:param private_port:
:param province_id:
:param isp_id:
:param city_id:
:param stun_ip:
:param country:
:return:
"""
# startup_nodes = [{"host": REDIS_CLUSTER_HOST, "port": REDIS_CLUSTER_PORT},
# {"host": REDIS_CLUSTER_HOST_2, "port": REDIS_CLUSTER_PORT},
# {"host": REDIS_CLUSTER_HOST_3, "port": REDIS_CLUSTER_PORT}]
# rc = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)
key = "PNIC_" + str(peer_id)
value = {
"peer_id": str(peer_id),
"version": str(sdk_version),
"natType": int(nat_type),
"publicIP": str(public_ip),
"publicPort": int(public_port),
"privateIP": str(private_ip),
"privatePort": int(private_port),
"country": str(country),
"province_id": str(province_id),
"isp_id": str(isp_id),
"city_id": str(city_id),
"stunIP": str(stun_ip)
}
# 将dict转成json格式
value = JSONEncoder().encode(value)
rc.setex(key, int(ttl), value)
def cluster_fosc_add(file_id, isp, peer_id, sdk_version, nat_type, public_ip, public_port, private_ip, private_port,
province_id, stun_ip, cppc=1):
"""
在FOSC中set value，若非必要，尽量使用cache_report或control_report请求汇报，由ts-go服务器写入FOSC
目前服务器维护seed list不只单单使用FOSC，还涉及到LFC，LFCacheManageZset
:param file_id: 该key所对应的file_id
:param isp: 该key所对应的isp
:param peer_id:
:param sdk_version:
:param nat_type:
:param public_ip:
:param public_port:
:param private_ip:
:param private_port:
:param province_id:
:param stun_ip:
:param cppc:
:return:
"""
# startup_nodes = [{"host": REDIS_CLUSTER_HOST, "port": REDIS_CLUSTER_PORT},
# {"host": REDIS_CLUSTER_HOST_2, "port": REDIS_CLUSTER_PORT},
# {"host": REDIS_CLUSTER_HOST_3, "port": REDIS_CLUSTER_PORT}]
# rc = StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)
key = "{FOSC_" + str(file_id) + "_" + str(isp) + "}"
value = {
"peer_id": str(peer_id),
"version": str(sdk_version),
"natType": int(nat_type),
"publicIP": str(public_ip),
"publicPort": int(public_port),
"privateIP": str(private_ip),
"privatePort": int(private_port),
"province_id": str(province_id),
"stunIP": str(stun_ip),
"cppc": int(cppc)
}
# 将dict转成json格式
value = JSONEncoder().encode(value)
rc.sadd(key, value)
def redis_cluster_sadd_pdfc(peer_id, file_id, psize, ppc, operation, src=0):
"""
定向推送删除任务到某个peer
:param peer_id:
:param file_id:
:param psize:
:param ppc:
:param operation:
:param src:
:return:
"""
key = "PDFC_" + str(peer_id)
value = {
"file_id": str(file_id),
"psize": int(psize),
"ppc": int(ppc),
"operation": str(operation),
"src": src
}
# 将dict转成json格式
value = JSONEncoder().encode(value)
rc.sadd(key, value)
