def test_limit(self):
data = {
'query': {
'limit': [0, 1]
}
}
res = self.client.post(
self.uri, json.dumps(data), 'application/json'
)
self.assertEqual(res.status_code, 200)
data = json.loads(res.content)
# assert returns 1/3 matched posts
self.assertEqual(len(data['posts']), 1)
data = {
'query': {
'limit': [0, 2]
}
}
res = self.client.post(
self.uri, json.dumps(data), 'application/json'
)
self.assertEqual(res.status_code, 200)
data = json.loads(res.content)
# assert returns 2/3 matched posts
self.assertEqual(len(data['posts']), 2)
def test_order_by(self):
data = {
'query': {
'order_by': '-title'
}
}
res = self.client.post(
self.uri, json.dumps(data), 'application/json'
)
self.assertEqual(res.status_code, 200)
data = json.loads(res.content)
posts = data['posts']
self.assertEqual(posts[0]['title'], 'c')
self.assertEqual(posts[1]['title'], 'b')
self.assertEqual(posts[2]['title'], 'a')
data = {
'query': {
'order_by': 'title'
}
}
res = self.client.post(
self.uri, json.dumps(data), 'application/json'
)
self.assertEqual(res.status_code, 200)
data = json.loads(res.content)
posts = data['posts']
self.assertEqual(posts[0]['title'], 'a')
self.assertEqual(posts[1]['title'], 'b')
self.assertEqual(posts[2]['title'], 'c')
def _writeJson(self, json_rpc_response):
assert isinstance(json_rpc_response, JsonRpcResponse)
assert isinstance(json_rpc_response, dict)
self.response.content_type = "application/json"
json_string = dumps(json_rpc_response)
callback = self.request.get("callback")
if callback:
self.response.out.write("%s=(%s)" % (callback, json_string))
return
self.response.out.write(dumps(json_rpc_response))
return
def _writeJson(self, json_rpc_response):
assert isinstance(json_rpc_response, JsonRpcResponse)
assert isinstance(json_rpc_response, dict)
self.response.content_type = "application/json"
json_string = dumps(json_rpc_response)
callback = self.request.get("callback")
if callback:
self.response.out.write("%s=(%s)" % (callback, json_string))
return
self.response.out.write(dumps(json_rpc_response))
return
def health():
#this is where we will parse csv and then construct a dictionary out of it
data = csvParser.csvParse("health", "health")
#return the dictionary(json data) in string format.
#NOTE: it has to be in string format, browser cannot display json.
return json.dumps(data)
def to_write_json(**page_dict):
result = {}
for attr_name in Page.attrset:
if attr_name in page_dict:
result[attr_name] = page_dict[attr_name]
json_ustr = json.dumps({'page':result},ensure_ascii=False)
return json_ustr.encode('utf-8')
def _write(self, json_rpc_response):
"""write JSON-RPC response as it is"""
assert isinstance(json_rpc_response, JsonRpcResponse)
assert isinstance(json_rpc_response, dict)
if json_rpc_response.getRedirectTarget():
assert isinstance(self.response, Response)
self.redirect(json_rpc_response.getRedirectTarget())
#debug("redirecting to %s" % json_rpc_response.getRedirectTarget())
return
# notification has no id
if json_rpc_response.getId() is None:
#debug("JSON-RPC notification")
if not json_rpc_response.has_key("error") and not json_rpc_response.has_key("result"):
# http://www.simple-is-better.org/json-rpc/jsonrpc20-over-http.html
self.response.set_status(204) # No content
self.response.content_type = "text/plain"
return
json_rpc_response.setError(JsonRpcError.INVALID_REQUEST,
"Response for notification should have neither result nor error.")
if json_rpc_response.has_key("error"):
#debug("JSON RPC response with error.")
#assert json_rpc_response.getResult() is None
self.response.content_type = "application/json"
json_rpc_error_code = json_rpc_response.getErrorCode()
http_status_code = JsonRpcDispatcher._getHttpStatusFromJsonRpcError(json_rpc_error_code)
self.response.set_status(http_status_code)
json_string = dumps(json_rpc_response)
self.response.out.write(dumps(json_rpc_response))
return
# HTTP response in given format
if self.request.get("format") == "tsv":
self._writeTsv(json_rpc_response)
return
if self.request.get("format") == "csv":
self._writeCsv(json_rpc_response)
return
if self.request.get("format") == "DataTable":
self._writeDataTable(json_rpc_response)
return
self._writeJson(json_rpc_response)
def test_count(self):
data = {
'query': 'count'
}
res = self.client.post(
self.uri, json.dumps(data), 'application/json'
)
self.assertEqual(res.status_code, 200)
self.assertEqual(Post.objects.count(), int(res.content))
uri = reverse('apis:comments')
data = {
'query': 'count'
}
res = self.client.post(
uri, json.dumps(data), 'application/json'
)
self.assertEqual(res.status_code, 200)
self.assertEqual(Comment.objects.count(), int(res.content))
def test_is_sql(self):
data = {
'query': 'SELECT * WHERE ...'
}
res = self.client.post(
self.uri, json.dumps(data), 'application/json'
)
self.assertEqual(res.status_code, 400)
data = {
'query': 'WHERE user__pk'
}
res = self.client.post(
self.uri, json.dumps(data), 'application/json'
)
self.assertEqual(res.status_code, 200)
data = json.loads(res.content)
# assert returns 1/3 matched posts
self.assertEqual(len(data['posts']), 1)
def error_response(code, error, error_type='error'):
return {
'statusCode':
code,
'body':
json.dumps({
'type': error_type,
'error': str(error),
'errorClass': str(type(error))
})
}
def get(self):
self.sender = GetSender(self.request)
self.raw_data = putRawData(self.request)
# self.data_list = putDataList(self.request)
self.data_list = Data.storeRequest(self.request)
self.metadata = putMetadata(self.sender, self.raw_data, self.data_list)
assert isinstance(self.response, webapp.Response)
self.response.headers["Content-Type"] = "text/plain"
for key in self.data_list:
data = db.get(key)
if data.field == "productName":
self.productName = data.string
if data.field == "serialNumber":
self.serialNumber = data.string
if data.field == "moduleId":
self.moduleId = data.string
# self.response.out.write("field:" + data.field + " string:" + data.string + "\n")
try:
relays = Relays(self.productName, self.serialNumber, self.moduleId)
assert isinstance(relays, Relays)
l = []
for k, v in relays.iteritems():
assert isinstance(v, Relay)
r = {
"relayId": v.relayId,
# "scheduledDateTime" : v.scheduledDateTime,
"scheduledEpoch": nativeToEpoch(v.scheduledDateTime),
"expectedState": v.expectedState,
}
l.append(r)
o = {"relayStates": l}
self.response.out.write(dumps(o))
except AttributeError, e:
l = map(lambda key: db.get(key), self.data_list)
j = dumps(l)
self.response.out.write(j)
def get(self):
self.sender = GetSender(self.request)
self.raw_data = putRawData(self.request)
# self.data_list = putDataList(self.request)
self.data_list = Data.storeRequest(self.request)
self.metadata = putMetadata(self.sender, self.raw_data, self.data_list)
assert isinstance(self.response, webapp.Response)
self.response.headers['Content-Type'] = "text/plain"
for key in self.data_list:
data = db.get(key)
if data.field == "productName":
self.productName = data.string
if data.field == "serialNumber":
self.serialNumber = data.string
if data.field == "moduleId":
self.moduleId = data.string
#self.response.out.write("field:" + data.field + " string:" + data.string + "\n")
try:
relays = Relays(self.productName, self.serialNumber, self.moduleId)
assert isinstance(relays, Relays)
l = []
for k, v in relays.iteritems():
assert isinstance(v, Relay)
r = {
"relayId": v.relayId,
#"scheduledDateTime" : v.scheduledDateTime,
"scheduledEpoch": nativeToEpoch(v.scheduledDateTime),
"expectedState": v.expectedState
}
l.append(r)
o = {"relayStates": l}
self.response.out.write(dumps(o))
except AttributeError, e:
l = map(lambda key: db.get(key), self.data_list)
j = dumps(l)
self.response.out.write(j)
def get(self):
gql = RawData.gql("ORDER BY rawDataId DESC LIMIT 5000")
records = gql.run()
results = []
for record in records:
query_dict = cgi.parse_qs(record.query)
if query_dict.has_key("arduinoid"):
try:
gen_power = query_dict["gen.power(W)"][0]
timestring = query_dict["time"][0]
except: continue
results.append([gen_power, timestring[0:4], timestring[4:6], timestring[6:8], timestring[8:10], timestring[10:12], timestring[12:14]])
#results.append([gen_power])
self.response.out.write(self.request.get("callback") + "(" + dumps({"timeVsWatt":results}) + ");")
def test_create(self):
data = {'post': {
'title': 'New Book',
'content': '',
'user_id': '1'
}}
uri = reverse('apis:posts')
res = self.client.post(uri, json.dumps(data), 'application/json')
self.assertEqual(res.status_code, 200)
data = json.loads(res.content)
post = Post.objects.latest('pk')
self.assertEqual(post.pk, data['post']['id'])
self.assertEqual(post.title, data['post']['title'])
self.assertEqual(post.content, data['post']['content'])
self.assertEqual(post.user.pk, data['post']['user_id'])
def test_exclude(self):
data = {
'query': {
'exclude': {
'user__pk': 1
}
}
}
res = self.client.post(
self.uri, json.dumps(data), 'application/json'
)
self.assertEqual(res.status_code, 200)
data = json.loads(res.content)
# assert returns 1/3 matched posts
self.assertEqual(len(data['posts']), 1)
def test_create(self):
self.client = Client()
self.client.login(username='******', password='******')
data = {'post': {
'title': 'New Book',
'content': ' ',
'user_id': '1'
}}
uri = reverse('apis:posts')
res = self.client.post(uri, json.dumps(data), 'application/json')
self.assertEqual(res.status_code, 403)
posts = Post.objects.all()
# assert no new post was created
self.assertEqual(posts.count(), 3)
def add_backend(event, context):
try:
params = add_backend_schema_request.validate(json.loads(event['body']))
except json.JSONDecodeError as e:
return error_response(400, e, error_type='parse_error')
except SchemaError as e:
return error_response(400, e, error_type='validation_error')
params.update({
'is_healthy': False,
'when_added': datetime.utcnow().isoformat()
})
table = get_table()
try:
response = table.put_item(Item=params)
except Exception as e:
return error_response(500, e)
return {'statusCode': 201, 'body': json.dumps(params)}
def _writeDataTable(self, jresponse):
debug("format=DataTable")
assert isinstance(jresponse, JsonRpcResponse)
columns = jresponse.getColumns()
if not columns:
warn("Column description is not set in JSON-RPC response object.")
return
assert isinstance(columns, Columns)
rows = []
for x in jresponse.getResult():
assert isinstance(x, DataTableMixin)
row = x.to_row(columns)
debug(row)
rows.append(row)
data_table = {"cols": jresponse.getColumns(), "rows":rows}
info(str(data_table))
self.response.out.write(dumps(data_table))
self.response.content_type = "application/javascript"
def test_update(self):
post = Post.objects.all()[0]
data = {'post': {
'title': 'New Book',
'content': '',
'user_id': '1'
}}
uri = reverse('apis:post', kwargs={
'pk': post.pk
})
res = self.client.put(uri, json.dumps(data), 'application/json')
self.assertEqual(res.status_code, 200)
data = json.loads(res.content)
post = Post.objects.get(pk=post.pk)
self.assertEqual(post.pk, data['post']['id'])
self.assertEqual(post.title, data['post']['title'])
self.assertEqual(post.content, data['post']['content'])
self.assertEqual(post.user.pk, data['post']['user_id'])
def _writeDataTable(self, jresponse):
debug("format=DataTable")
assert isinstance(jresponse, JsonRpcResponse)
columns = jresponse.getColumns()
if not columns:
warn("Column description is not set in JSON-RPC response object.")
return
assert isinstance(columns, Columns)
rows = []
for x in jresponse.getResult():
assert isinstance(x, DataTableMixin)
row = x.to_row(columns)
debug(row)
rows.append(row)
data_table = {"cols": jresponse.getColumns(), "rows": rows}
info(str(data_table))
self.response.out.write(dumps(data_table))
self.response.content_type = "application/javascript"
def get(self):
gql = RawData.gql("ORDER BY rawDataId DESC LIMIT 5000")
records = gql.run()
results = []
for record in records:
query_dict = cgi.parse_qs(record.query)
if query_dict.has_key("arduinoid"):
try:
gen_power = query_dict["gen.power(W)"][0]
timestring = query_dict["time"][0]
except:
continue
results.append([
gen_power, timestring[0:4], timestring[4:6],
timestring[6:8], timestring[8:10], timestring[10:12],
timestring[12:14]
])
#results.append([gen_power])
self.response.out.write(
self.request.get("callback") + "(" +
dumps({"timeVsWatt": results}) + ");")
def main():
cmd.title("IT之家最近更新")
# cmd.size(66,36)
try:
soups = html.soup(html.getsoup("http://wap.ithome.com/").find_all("ul",attrs={"id": "wapindexnewlist"})).find_all("li")
jsondata = json.data()
jsondata = []
for soup in soups:
if len(soup.find_all("span",attrs={"class": "title"})) > 0:
link = json.data()
s = str(soup.find_all("span",attrs={"class": "title"})[0])
link["title"] = s[s.rfind("\">")+3:s.rfind("</")]
s = str(soup.find_all("span",attrs={"class": "date"})[0])
link["time"] = s[s.rfind("('")+2:s.rfind("')")]
link["link"] = "http://www.ithome.com" + soup.find_all("a")[0].attrs["href"]
jsondata.append(link)
print(json.dumps(jsondata).replace(" "," "))
json.savefile(jsondata,paths.startpath() + "/Save.json")
except Exception as e:
print(e)
cmd.pause("执行完成，按任意键继续...")
def dumps(self, obj):
p = pack(obj)
return dumps(p)
def pack(self, obj, fp):
return fp.write(dumps(obj))
def write_index_file(self):
f = open(DEFAULT_INDEX_FILE,'w')
f.write(json.dumps(self.ihash))
def list_backends(event, context):
table = get_table()
items = table.scan()
return {'statusCode': 200, 'body': json.dumps(items['Items'])}
