def exploit(request):
if not request.url.params:
return
for param in request.url.params: # only get
for poc in SQL_POCS:
injectable = False
req_tmp = request.copy()
req_tmp.__class__ = GetRequest
req_tmp.setParam(param, req_tmp.getParam(param) + poc)
for (dbms, regex) in ((dbms, regex) for dbms in SQLI_ERROR_SINGS for regex in SQLI_ERROR_SINGS[dbms]):
if re.search(regex, req_tmp.fetch(), re.I):
# print "%s" % req_tmp
util.report({"type":"sqli", "content":util.json_encode({"sqli_type":"%s Error Based" % dbms, "param":param, "detail":"%s" % req_tmp})})
return
for prefix, suffix in itertools.product(SQL_PREFIXES, SQL_SUFFIXES):
poc1 = "%s AND 1=1 %s" % (prefix, suffix)
poc2 = "%s AND 1=2 %s" % (prefix, suffix)
req_tmp1 = request.copy()
req_tmp1.__class__ = GetRequest
req_tmp1.setParam(param, req_tmp1.getParam(param) + poc1)
req_tmp2 = request.copy()
req_tmp2.__class__ = GetRequest
req_tmp2.setParam(param, req_tmp2.getParam(param) + poc2)
if (len(req_tmp1.fetch()) != len(req_tmp2.fetch())):
util.report({"type":"sqli", "content":util.json_encode({"sqli_type":"UNION query", "param":param, "detail":"%s" % req_tmp})})
# print "UNION SQLI:param %s %s" % (param,req_tmp2)
return
def process(self, **kwargs):
payload = kwargs.get("payload", {})
extra = kwargs.get("extra", {})
alert = kwargs.get("alert", None)
apns = kwargs.get("apns", None)
token = kwargs["token"]
if alert is not None and not isinstance(alert, dict):
alert = {"body": alert, "title": alert}
payload_data = {"aps": {"alert": alert, **apns}}
payload = json_encode(payload_data)
PATH = "/3/device/{0}".format(token)
headers = self.build_headers()
logging.info(payload)
self.http2.request("POST", PATH, payload, headers=headers)
resp = self.http2.get_response()
if resp.status >= 400:
headers = resp.headers
# for k, v in headers.items():
# logging.error("%s: %s" % (k.decode("utf-8"), v.decode("utf-8")))
body = resp.read().decode("utf-8")
logging.error(body)
raise ApnsException(400, body)
def areas():
lat = float(request.args['lat'])
lon = float(request.args['lon'])
include_geom = bool(request.args.get('include_geom', True))
pretty = bool(request.args.get('pretty', False))
json_callback = request.args.get('callback', None)
# This. Is. Python.
ogr.UseExceptions()
features = []
point = ogr.Geometry(wkt='POINT(%f %f)' % (lon, lat))
args = point, include_geom
#
# Look at four files in turn
#
for (dataname, shpname, zipname) in filenames:
features += get_intersecting_features(ogr.Open(shpname), dataname, *args)
geojson = dict(type='FeatureCollection', features=features)
body, mime = json_encode(geojson, pretty=pretty), 'application/json'
if json_callback:
body = '%s(%s);\n' % (json_callback, body)
mime = 'text/javascript'
return Response(body, headers={'Content-type': mime})
def areas():
''' Retrieve geographic areas.
'''
is_census = is_census_datasource(environ)
lat = float(request.args['lat'])
lon = float(request.args['lon'])
include_geom = bool(request.args.get('include_geom', True))
json_callback = request.args.get('callback', None)
layer_names = is_census and request.args.get('layers', '')
layer_names = layer_names and set(layer_names.split(','))
# This. Is. Python.
ogr.UseExceptions()
point = ogr.Geometry(wkt='POINT(%f %f)' % (lon, lat))
if is_census:
features = census_features(point, include_geom, layer_names)
else:
datasource = get_datasource(environ)
features = get_intersecting_features(datasource, point, include_geom)
geojson = dict(type='FeatureCollection', features=features)
body, mime = json_encode(geojson), 'application/json'
if json_callback:
body = '%s(%s);\n' % (json_callback, body)
mime = 'text/javascript'
return Response(body, headers={'Content-type': mime, 'Access-Control-Allow-Origin': '*'})
def select():
''' Retrieve features.
'''
if is_census_datasource(environ):
error = "Can't select individual features from " + census_url
return Response(render_template('error.html', error=error), status=404)
where_clause = request.args.get('where', None)
where_clause = where_clause and str(where_clause)
page_number = int(request.args.get('page', 1))
include_geom = bool(request.args.get('include_geom', True))
json_callback = request.args.get('callback', None)
# This. Is. Python.
ogr.UseExceptions()
try:
datasource = get_datasource(environ)
features = get_matching_features(datasource, where_clause, page_number, include_geom)
except QueryError, e:
body, mime = json_encode({'error': str(e)}), 'application/json'
if json_callback:
body = '%s(%s);\n' % (json_callback, body)
mime = 'text/javascript'
return Response(body, status=400, headers={'Content-type': mime, cors: '*'})
def build_request(self, token, alert, **kwargs):
if alert is not None and not isinstance(alert, dict):
alert = {"body": alert, "title": alert}
fcm_param = kwargs.get("payload", {})
android = fcm_param.get("android", {})
apns = fcm_param.get("apns", {})
webpush = fcm_param.get("webpush", {})
data = fcm_param.get("data", {})
# data structure: https://firebase.google.com/docs/reference/fcm/rest/v1/projects.messages
payload = {"message": {"token": token}}
if alert:
payload["message"]["notification"] = self.format_values(alert)
if data:
payload["message"]["data"] = self.format_values(data)
if android:
payload["message"]["android"] = android
if webpush:
payload["message"]["webpush"] = webpush
if apns:
payload["message"]["apns"] = apns
text = json_encode(payload)
return text
def post(self):
id = self.get_argument("id", None)
content = self.get_argument("content", None)
if not (id and content and self.current_user): return
page = self.get_argument("page", None)
user_id = self.current_user["_id"]
comment = {
"_id": self.comment_dal.get_id(),
"user_id": user_id,
"user": self.comment_dal.dbref("users", user_id),
"entry_id": int(id),
"entry": self.comment_dal.dbref("entries", int(id)),
"content": content,
"published": datetime.datetime.now()
}
cid = self.comment_dal.save(comment)
self.entry_dal.update_comments_count(int(id))
comment = self.comment_dal.get({"_id": cid})
if not page:
html = self.render_string("modules/mini_comment.html",
comment=comment)
else:
html = self.render_string("modules/comment.html", comment=comment)
self.write("{id: %s, html: '%s'}" % (id, util.json_encode(html)))
async def remind(ctx, time, *, reminder):
reminder = reminder.strip()
if len(reminder) > 512:
await ctx.send(embed=util.error_embed(
"Maximum reminder length is 512 characters",
"Foolish user error"))
return
extra_data = {
"author_id": ctx.author.id,
"channel_id": ctx.message.channel.id,
"message_id": ctx.message.id,
"guild_id": ctx.message.guild and ctx.message.guild.id,
"original_time_spec": time
}
try:
now = datetime.now(tz=timezone.utc)
time = util.parse_time(time)
except:
await ctx.send(embed=util.error_embed(
"Invalid time (wrong format/too large/non-integer months or years)"
))
return
await bot.database.execute(
"INSERT INTO reminders (remind_timestamp, created_timestamp, reminder, expired, extra) VALUES (?, ?, ?, ?, ?)",
(time.timestamp(), now.timestamp(), reminder, 0,
util.json_encode(extra_data)))
await bot.database.commit()
await ctx.send(
f"Reminder scheduled for {util.format_time(time)} ({util.format_timedelta(now, time)})."
)
async def remind(self, ctx, time, *, reminder):
reminder = reminder.strip()
if len(reminder) > 512:
await ctx.send(embed=util.error_embed(
"Maximum reminder length is 512 characters",
"Foolish user error"))
return
extra_data = {
"author_id": ctx.author.id,
"channel_id": ctx.message.channel.id,
"message_id": ctx.message.id,
"guild_id": ctx.message.guild and ctx.message.guild.id,
"original_time_spec": time
}
tz = await util.get_user_timezone(ctx)
try:
now = datetime.now(tz=timezone.utc)
time = util.parse_time(time, tz)
except:
await ctx.send(embed=util.error_embed(
"Invalid time (wrong format/too large months or years)"))
return
utc_time, local_time = util.in_timezone(time, tz)
id = (await self.bot.database.execute_insert(
"INSERT INTO reminders (remind_timestamp, created_timestamp, reminder, expired, extra) VALUES (?, ?, ?, ?, ?)",
(utc_time.timestamp(), now.timestamp(), reminder, 0,
util.json_encode(extra_data))))["last_insert_rowid()"]
await self.bot.database.commit()
await ctx.send(
f"Reminder scheduled for {util.format_time(local_time)} ({util.format_timedelta(now, utc_time)})."
)
self.insert_reminder(id, utc_time.timestamp())
def post(self):
id = self.get_argument("id", None)
content = self.get_argument("content", None)
if not (id and content and self.current_user): return
page = self.get_argument("page", None)
user_id = self.current_user["_id"]
comment = {
"_id": self.comment_dal.get_id(),
"user_id": user_id,
"user": self.comment_dal.dbref("users", user_id),
"entry_id": int(id),
"entry": self.comment_dal.dbref("entries", int(id)),
"content": content,
"published": datetime.datetime.now()
}
cid = self.comment_dal.save(comment)
self.entry_dal.update_comments_count(int(id))
comment = self.comment_dal.get({"_id": cid})
if not page:
html = self.render_string(
"modules/mini_comment.html", comment=comment)
else:
html = self.render_string(
"modules/comment.html", comment=comment)
self.write("{id: %s, html: '%s'}" % (id, util.json_encode(html)))
def process(self, **kwargs):
alert = kwargs.get("alert", None)
apns = kwargs.get("apns", {})
token = kwargs["token"]
if alert is not None and not isinstance(alert, dict):
alert = {"body": alert, "title": alert}
# data structure:
# https://developer.apple.com/library/archive/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/PayloadKeyReference.html#//apple_ref/doc/uid/TP40008194-CH17-SW1
payload_data = {"aps": {"alert": alert, **apns}}
payload = json_encode(payload_data)
self.payload = payload
PATH = "/3/device/{0}".format(token)
self.headers = self.build_headers()
self.http2.request("POST", PATH, payload, headers=self.headers)
resp = self.http2.get_response()
if resp.status >= 400:
# headers = resp.headers
# for k, v in headers.items():
# logging.error("%s: %s" % (k.decode("utf-8"), v.decode("utf-8")))
body = resp.read().decode("utf-8")
logging.error(body)
raise ApnsException(400, body)
def read_config(args):
if not os.path.isfile("config.json"):
print "config.json does not exist! Please copy config-sample.json to config.json and edit to your liking, then run the script."
sys.exit(1)
countries = args.country
if isinstance(countries, basestring):
countries = [countries]
countries = [country.lower().strip() for country in countries]
for country in countries:
if not os.path.isfile("proxies/proxies-%s.json" % country):
print "The proxy configuration file proxies-%s.json does not exist! Exiting." % country
sys.exit(1)
content = util.get_contents("config.json")
config = util.json_decode(content)
if args.ip:
config["public_ip"] = args.ip
if args.bind_ip:
config["bind_ip"] = args.ip
if args.base_ip:
config["base_ip"] = args.base_ip
if args.base_port:
config["base_port"] = args.base_port
if not config["public_ip"]:
try:
print("Autodetecting public IP address...")
public_ip = urllib2.urlopen("http://l2.io/ip").read().strip()
print("Detected public IP as %s. If it's wrong, please cancel the script now and set it in config.json or specify with --ip" % public_ip)
time.sleep(1)
config["public_ip"] = public_ip
except:
print("Could not detect public IP. Please update the public_ip setting in config.json or specify with --ip.")
sys.exit(1)
if args.save:
util.put_contents('config.json', util.json_encode(config))
groups = {}
for country in countries:
groups.update(util.json_decode(util.get_contents("proxies/proxies-%s.json" % country)))
if args.only:
only = set(args.only)
for item in args.only:
if item not in groups:
print "Nonexistent Item: %s, exiting" % item
sys.exit()
for item in groups.keys():
if item not in only:
del groups[item]
elif args.skip:
for item in args.skip:
del groups[item]
config["groups"] = groups
return config
def exploit(request):
if not request.url.params:
return
for param in request.url.params: # only get
for poc in SQL_POCS:
injectable = False
req_tmp = request.copy()
req_tmp.__class__ = GetRequest
req_tmp.setParam(param, req_tmp.getParam(param) + poc)
for (dbms, regex) in ((dbms, regex) for dbms in SQLI_ERROR_SINGS
for regex in SQLI_ERROR_SINGS[dbms]):
if re.search(regex, req_tmp.fetch(), re.I):
# print "%s" % req_tmp
util.report({
"type":
"sqli",
"content":
util.json_encode({
"sqli_type": "%s Error Based" % dbms,
"param": param,
"detail": "%s" % req_tmp
})
})
return
for prefix, suffix in itertools.product(SQL_PREFIXES, SQL_SUFFIXES):
poc1 = "%s AND 1=1 %s" % (prefix, suffix)
poc2 = "%s AND 1=2 %s" % (prefix, suffix)
req_tmp1 = request.copy()
req_tmp1.__class__ = GetRequest
req_tmp1.setParam(param, req_tmp1.getParam(param) + poc1)
req_tmp2 = request.copy()
req_tmp2.__class__ = GetRequest
req_tmp2.setParam(param, req_tmp2.getParam(param) + poc2)
if (len(req_tmp1.fetch()) != len(req_tmp2.fetch())):
util.report({
"type":
"sqli",
"content":
util.json_encode({
"sqli_type": "UNION query",
"param": param,
"detail": "%s" % req_tmp
})
})
# print "UNION SQLI:param %s %s" % (param,req_tmp2)
return
def send_response(self, status_code=200, data=None, headers=None):
""" Set REST API response """
self.set_status(status_code, None)
if headers is not None:
self.set_headers(headers)
if data:
data = json_encode(data)
else:
data = ""
self.finish(data)
def features_geojson(features, json_callback):
'''
'''
geojson = dict(type='FeatureCollection', features=features)
body, mime = json_encode(geojson), 'application/json'
if json_callback:
body = '%s(%s);\n' % (json_callback, body)
mime = 'text/javascript'
return body, mime
def ssh_write(host, state):
d = tempfile.mkdtemp()
try:
filename = os.path.join(d, 'glidein_state')
with open(filename, 'w') as f:
f.write(json_encode(state))
cmd = ['scp', filename, host + ':~/glidein_state']
if subprocess.call(cmd):
raise Exception('error in ssh copy of state')
finally:
shutil.rmtree(d)
def features_geojson(features, json_callback):
'''
'''
geojson = dict(type='FeatureCollection', features=features)
body, mime = json_encode(geojson), 'application/json'
if json_callback:
body = '%s(%s);\n' % (json_callback, body)
mime = 'text/javascript'
return body, mime
def ssh_write(host,state):
d = tempfile.mkdtemp()
try:
filename = os.path.join(d,'glidein_state')
with open(filename,'w') as f:
f.write(json_encode(state))
cmd = ['scp',filename,host+':~/glidein_state']
if subprocess.call(cmd):
raise Exception('error in ssh copy of state')
finally:
shutil.rmtree(d)
def scanner():
info = {}
info["app"] = []
info["web"] = []
for port in g.O["web-ports"]:
data = scan_web_server(g.O["target"], int(port))
if data is not None:
util.report({"type": "sys_info", "content": util.json_encode(data)})
info["web"].append(data)
for port in g.O["app-ports"]:
# print port
data = scan_app_service(g.O["target"], int(port))
# print type(data)
if data is not None:
# print encode_dict(data)
util.report({"type": "sys_info", "content": util.json_encode(data)})
info["app"].append(data)
return info
def exploit(request):
if not request.url.params and not request.fields:
return
if isinstance(request, GetRequest):
for param, poc in itertools.product(request.url.params, XSS_POCS):
req_tmp = request.copy()
req_tmp.__class__ = GetRequest
req_tmp.setParam(param, req_tmp.getParam(param)+poc)
if poc in req_tmp.fetch():
#print "xss vulnerability param:%s info:%s" % (param, req_tmp)
util.report({"type":"xss","content":util.json_encode({"xss_type":"GET","param":param,"detail":"%s" % req_tmp})})
break
else:
for field, poc in itertools.product(request.fields, XSS_POCS):
req_tmp = request.copy()
req_tmp.__class__ = PostRequest
req_tmp.setField(field, req_tmp.getField(field)+poc)
if poc in req_tmp.fetch():
#print "xss vulnerability param:%s info:%s" % (field, req_tmp)
util.report({"type":"xss","content":util.json_encode({"xss_type":"POST","field":field,"detail":"%s" % req_tmp})})
break
def build_request(self, regids, data, collapse_key, ttl):
payload = {"registration_ids": regids}
if data:
payload["data"] = data
if ttl >= 0:
payload["time_to_live"] = ttl
if collapse_key:
payload["collapse_key"] = collapse_key
return json_encode(payload)
def post(self):
result = {"code": 200, "msg": "OK", "end": 0, "html": ""}
offset = int(self.get_argument("offset", "0"))
p = int(self.get_argument("p", "1"))
user_id = self.get_argument("user_id", None)
filter = self.get_argument("filter", "None")
if not filter in ("friends", "followers") and user_id:
self._render_error(result)
return
p = 1 if p < 1 else p
if filter == "friends":
total = self.relation.get_friends_count(int(user_id))
else:
total = self.relation.get_followers_count(int(user_id))
if total <= 0:
self._render_error(result)
return
tmp = offset
offset = (p - 1) * MAX_PAGE_SIZE + offset
limit = PAGE_SIZE
if filter == "friends":
users = self.relation.get_friends(int(user_id), offset, limit)
else:
users = self.relation.get_followers(int(user_id), offset, limit)
"""Get Relations for the current user."""
if self.current_user:
ids = [u["_id"] for u in users]
ifriends = self.relation.get_relations_by_ids(
self.current_user["_id"], ids)
for user in users:
user["ifollow"] = True if user["_id"] in ifriends else False
tmp = tmp + len(users)
htmls = []
for i in range(0, len(users)):
args = {'user': users[i], 'odd': True if i % 2 == 0 else False}
html = self.render_string("modules/person.html", **args)
htmls.append(util.json_encode(html))
result["html"] = htmls
pager = tmp % MAX_PAGE_SIZE == 0
final = (offset + len(users)) >= total
if pager: result["end"] = 1
if final: result["end"] = 2
self.render("ajax/pubu.json", result=result)
def status():
datasource = get_datasource(environ)
status = {
'status': 'ok' if bool(datasource) else 'Bad datasource: %s' % repr(datasource),
'updated': int(time()),
'dependencies': [],
'resources': {}
}
body = json_encode(status)
return Response(body, headers={'Content-type': 'application/json', cors: '*'})
def scanner():
info = {}
info['app'] = []
info['web'] = []
for port in g.O['web-ports']:
data = scan_web_server(g.O['target'], int(port))
if data is not None :
util.report({"type":"sys_info", "content":util.json_encode(data)})
info['web'].append(data)
for port in g.O['app-ports']:
# print port
data = scan_app_service(g.O['target'], int(port))
# print type(data)
if data is not None :
# print encode_dict(data)
util.report({"type":"sys_info", "content":util.json_encode(data)})
info['app'].append(data)
return info
def post(self):
result = {"code": 200, "msg": "OK", "end": 0, "html": ""}
offset = int(self.get_argument("offset", "0"))
p = int(self.get_argument("p", "1"))
user_id = self.get_argument("user_id", None)
filter = self.get_argument("filter", "None")
if not filter in ("friends", "followers") and user_id:
self._render_error(result)
return
p = 1 if p < 1 else p
if filter == "friends":
total = self.relation.get_friends_count(int(user_id))
else:
total = self.relation.get_followers_count(int(user_id))
if total <= 0:
self._render_error(result)
return
tmp = offset
offset = (p - 1) * config.MAX_PAGE_SIZE + offset
limit = config.MINI_PAGE_SIZE
if filter == "friends":
users = self.relation.get_friends(int(user_id), offset, limit)
else:
users = self.relation.get_followers(int(user_id), offset, limit)
"""Get Relations for the current user."""
if self.current_user:
ids = [u["_id"] for u in users]
ifriends = self.relation.get_relations_by_ids(
self.current_user["_id"], ids)
for user in users:
user["ifollow"] = True if user["_id"] in ifriends else False
tmp = tmp + len(users)
htmls = []
for i in range(0, len(users)):
args = {'user': users[i], 'odd': True if i % 2 == 0 else False}
html = self.render_string("modules/person.html", **args)
htmls.append(util.json_encode(html))
result["html"] = htmls
pager = tmp % config.MAX_PAGE_SIZE == 0
final = (offset + len(users)) >= total
if pager: result["end"] = 1
if final: result["end"] = 2
self.render("ajax/pubu.json", result=result)
def request(self, methodname, kwargs):
"""Send request to RPC Server"""
# check method name for bad characters
if methodname[0] == '_':
logger.warning('cannot use RPC for private methods')
raise Exception('Cannot use RPC for private methods')
# translate request to json
body = json_encode({
'jsonrpc': '2.0',
'method': methodname,
'params': kwargs,
'id': Client.newid()
})
headers = {'Content-type': 'application/json'}
request = urllib2.Request(self._address, data=body, headers=headers)
# make request to server
try:
response = urllib2.urlopen(request, timeout=self._timeout)
except Exception:
logger.warn('error making jsonrpc request', exc_info=True)
raise
# translate response from json
try:
cb_data = response.read()
data = json_decode(cb_data)
except Exception:
try:
logger.info('json data: %r', cb_data)
except Exception:
pass
raise
if 'error' in data:
try:
raise Exception('Error %r: %r %r' % data['error'])
except Exception:
raise Exception('Error %r' % data['error'])
if 'result' in data:
return data['result']
else:
return None
def status():
datasource = get_datasource(environ)
status = {
'status':
'ok' if bool(datasource) else 'Bad datasource: %s' % repr(datasource),
'updated':
int(time()),
'dependencies': [],
'resources': {}
}
body = json_encode(status)
return Response(body,
headers={
'Content-type': 'application/json',
cors: '*'
})
def request(self, methodname, kwargs):
"""Send request to RPC Server"""
# check method name for bad characters
if methodname[0] == '_':
logger.warning('cannot use RPC for private methods')
raise Exception('Cannot use RPC for private methods')
# translate request to json
body = json_encode({'jsonrpc': '2.0', 'method': methodname,
'params': kwargs, 'id': Client.newid()})
headers = {'Content-type':'application/json'}
request = urllib2.Request(self._address, data=body, headers=headers)
# make request to server
try:
response = urllib2.urlopen(request, timeout=self._timeout)
except Exception:
logger.warn('error making jsonrpc request', exc_info=True)
raise
# translate response from json
try:
cb_data = response.read()
data = json_decode(cb_data)
except Exception:
try:
logger.info('json data: %r', cb_data)
except Exception:
pass
raise
if 'error' in data:
try:
raise Exception('Error %r: %r %r'%data['error'])
except Exception:
raise Exception('Error %r'%data['error'])
if 'result' in data:
return data['result']
else:
return None
def format_values(self, data=None):
if not isinstance(data, dict):
return data
# Try to convert all fields to string.
formatted = {}
for (k, v) in data.items():
if isinstance(v, bool):
formatted[k] = "1" if v else "0"
elif isinstance(v, dict):
try:
formatted[k] = json_encode(self.format_values(v))
except:
logging.error("Error treating field " + k)
elif v is not None:
formatted[k] = str(v)
return formatted
def select():
''' Retrieve features.
'''
if is_census_datasource(environ):
error = "Can't select individual features from " + census_url
return Response(render_template('error.html', error=error), status=404)
where_clause = request.args.get('where', None)
where_clause = where_clause and str(where_clause)
page_number = int(request.args.get('page', 1))
include_geom = bool(request.args.get('include_geom', True))
json_callback = request.args.get('callback', None)
# This. Is. Python.
ogr.UseExceptions()
try:
datasource = get_datasource(environ)
features = get_matching_features(datasource, where_clause, page_number,
include_geom)
except QueryError, e:
body, mime = json_encode({'error': str(e)}), 'application/json'
if json_callback:
body = '%s(%s);\n' % (json_callback, body)
mime = 'text/javascript'
return Response(body,
status=400,
headers={
'Content-type': mime,
cors: '*'
})
def post(self):
result = {"code": 200, "msg": "OK", "end": 0, "html": ""}
offset = int(self.get_argument("offset", "0"))
p = int(self.get_argument("p", "1"))
user_id = self.get_argument("user_id", None)
filter = self.get_argument("filter", "-1")
category = self.get_argument("category", None)
q = self.get_argument("q", None)
p = 1 if p < 1 else p
if filter == "likes":
if not user_id:
result["code"] = 404
self.render("ajax/pubu.json", result=result)
return
total = self.fav_dal.get_user_like_entries_count(int(user_id))
elif user_id:
total = self.entry_dal.get_user_entries_count(int(user_id))
elif category:
total = self.entry_dal.get_entries_count_by_category(int(category))
elif q:
total = self.searchEngine.search_entries_count(q)
else:
total = self.entry_dal.get_count(None)
if total <= 0:
result["code"] = 404
self.render("ajax/pubu.json", result=result)
return
tmp = offset
offset = (p - 1) * MAX_PAGE_SIZE + offset
limit = PAGE_SIZE
if filter == "likes":
entries = self.fav_dal.get_user_like_entries(
int(user_id), offset, limit)
elif user_id:
entries = self.entry_dal.get_user_entries(
int(user_id), offset, limit)
elif category:
entries = self.entry_dal.get_entries_by_category(int(category), offset, limit)
elif q:
entries = self.searchEngine.search_entries(q, offset, limit)
else:
entries = self.entry_dal.query(None, offset, limit)
"""Get entry's comments"""
tweet_ids = [t["_id"] for t in entries]
comments = self.comment_dal.get_comments_by_ids(tweet_ids)
for tweet in entries:
tweet["comment_list"] = []
for comment in comments:
if tweet["_id"] == comment["entry_id"]:
tweet["comment_list"].append(comment)
"""Validate the current user is like this entry"""
if self.current_user:
fids = self.fav_dal.get_user_isliked(
self.current_user["_id"], tweet_ids)
for tweet in entries:
tweet["iliked"] = True if tweet["_id"] in fids else False
tmp = tmp + len(entries)
htmls = []
for entry in entries:
html = self.render_string("modules/entry.html", entry=entry)
htmls.append(util.json_encode(html))
result["html"] = htmls
pager = tmp % MAX_PAGE_SIZE == 0
final = (offset + len(entries)) >= total
if pager: result["end"] = 1
if final: result["end"] = 2
self.render("ajax/pubu.json", result=result)
def save(self, dir, msg):
msg = util.json_encode(msg)
lkey = {'in': 0, 'out': 1}[dir]
if self._last[lkey] < msg['MsgSeqNum']:
self._last[lkey] = msg['MsgSeqNum']
self.db.update([msg])
def write(self, chunk):
if isinstance(chunk, dict):
chunk = json_encode(chunk)
self.set_header("Content-Type", "application/json; charset=UTF-8")
chunk = utf8(chunk)
self._write_buffer.append(chunk)
fcv, fcsp = f['color'], f['color_speed']
else:
fcv, fcsp = SplEval(0), SplEval(0)
sansfinal = [v for k, v in gnm['xforms'].items() if k != 'final']
lc, rc = [
np.array([
v['color'](t) * (1 - fcsp(t)) + fcv(t) * fcsp(t) for v in sansfinal
]) for t in (0, 1)
]
rcrv = 1 - rc
# TODO: use spline integration instead of L2
dens = np.array(
[np.hypot(v['weight'](0), v['weight'](1)) for v in sansfinal])
return np.sum(np.abs(dens * (rc - lc))) > np.sum(np.abs(dens *
(rcrv - lc)))
def palflip(gnm):
for v in gnm['xforms'].values():
c = v['color']
v['color'] = SplEval([0, c(0), 1, 1 - c(1)], c(0, 1), -c(1, 1))
pal = genome.palette_decode(gnm['palettes'][1])
gnm['palettes'][1] = genome.palette_encode(np.flipud(pal))
if __name__ == "__main__":
import sys, json
a, b, c = [json.load(open(f + '.json')) for f in 'abc']
print json_encode(blend(a, b, c))
def __init__(self, object):
content = json_encode(object)
super(JsonResponse, self).__init__(content, mimetype='application/json')
def save(self, dir, msg):
msg = util.json_encode(msg)
lkey = {'in': 0, 'out': 1}[dir]
if self._last[lkey] < msg['MsgSeqNum']:
self._last[lkey] = msg['MsgSeqNum']
self.db.update([msg])
def post(self):
result = {"code": 200, "msg": "OK", "end": 0, "html": ""}
offset = int(self.get_argument("offset", "0"))
p = int(self.get_argument("p", "1"))
user_id = self.get_argument("user_id", None)
filter = self.get_argument("filter", "-1")
category = self.get_argument("category", None)
q = self.get_argument("q", None)
p = 1 if p < 1 else p
if filter == "likes":
if not user_id:
result["code"] = 404
self.render("ajax/pubu.json", result=result)
return
total = self.fav_dal.get_user_like_entries_count(int(user_id))
elif user_id:
total = self.entry_dal.get_user_entries_count(int(user_id))
elif category:
total = self.entry_dal.get_entries_count_by_category(int(category))
elif q:
total = self.searchEngine.search_entries_count(q)
else:
total = self.entry_dal.get_count(None)
if total <= 0:
result["code"] = 404
self.render("ajax/pubu.json", result=result)
return
tmp = offset
offset = (p - 1) * config.MAX_PAGE_SIZE + offset
limit = config.MINI_PAGE_SIZE
if filter == "likes":
entries = self.fav_dal.get_user_like_entries(
int(user_id), offset, limit)
elif user_id:
entries = self.entry_dal.get_user_entries(int(user_id), offset,
limit)
elif category:
entries = self.entry_dal.get_entries_by_category(
int(category), offset, limit)
elif q:
entries = self.searchEngine.search_entries(q, offset, limit)
else:
entries = self.entry_dal.query(None, offset, limit)
"""Get entry's comments"""
tweet_ids = [t["_id"] for t in entries]
comments = self.comment_dal.get_comments_by_ids(tweet_ids)
for tweet in entries:
tweet["comment_list"] = []
for comment in comments:
if tweet["_id"] == comment["entry_id"]:
tweet["comment_list"].append(comment)
"""Validate the current user is like this entry"""
if self.current_user:
fids = self.fav_dal.get_user_isliked(self.current_user["_id"],
tweet_ids)
for tweet in entries:
tweet["iliked"] = True if tweet["_id"] in fids else False
tmp = tmp + len(entries)
htmls = []
for entry in entries:
html = self.render_string("modules/entry.html", entry=entry)
htmls.append(util.json_encode(html))
result["html"] = htmls
pager = tmp % config.MAX_PAGE_SIZE == 0
final = (offset + len(entries)) >= total
if pager: result["end"] = 1
if final: result["end"] = 2
self.render("ajax/pubu.json", result=result)
for sd in izip_longest(ssort, dsort):
yield sd
def checkpalflip(gnm):
if 'final' in gnm['xforms']:
f = gnm['xforms']['final']
fcv, fcsp = f['color'], f['color_speed']
else:
fcv, fcsp = SplEval(0), SplEval(0)
sansfinal = [v for k, v in gnm['xforms'].items() if k != 'final']
lc, rc = [np.array([v['color'](t) * (1 - fcsp(t)) + fcv(t) * fcsp(t)
for v in sansfinal]) for t in (0, 1)]
rcrv = 1 - rc
# TODO: use spline integration instead of L2
dens = np.array([np.hypot(v['weight'](0), v['weight'](1))
for v in sansfinal])
return np.sum(np.abs(dens * (rc - lc))) > np.sum(np.abs(dens * (rcrv - lc)))
def palflip(gnm):
for v in gnm['xforms'].values():
c = v['color']
v['color'] = SplEval([0, c(0), 1, 1 - c(1)], c(0, 1), -c(1, 1))
pal = genome.palette_decode(gnm['palettes'][1])
gnm['palettes'][1] = genome.palette_encode(np.flipud(pal))
if __name__ == "__main__":
import sys, json
a, b, c = [json.load(open(f+'.json')) for f in 'abc']
print json_encode(blend(a, b, c))