def get(self, lat, lon): lat, lon = float(lat), float(lon) lat_100, lon_100 = int(lat*100+0.5), int(lon*100+0.5) key = "e2m:%s" % hashlib.md5("%s%s" % (lat_100, lon_100)).hexdigest() off_json = self.rdb.get(key) if not off_json: t_name = "offset_%s_%s" % (int(lat/3 + 0.5), int(lon/3 + 0.5)) try: entries = self.db.query("SELECT off_x, off_y FROM " + t_name + " WHERE lat=%s AND lon=%s", lat_100, lon_100) except Exception: entries = None if entries: off_dict = entries[0] self.rdb.set(key, json_encode(off_dict)) else: off_dict = None else: off_dict = json_decode(off_json) fake_lat, fake_lon = lat, lon if off_dict: op = OffsetPos(lat, lon, off_dict) fake_lat, fake_lon = op.getFakePos() fake_lat = float(decimal.Decimal(fake_lat).quantize(decimal.Decimal('0.000001'))) fake_lon = float(decimal.Decimal(fake_lon).quantize(decimal.Decimal('0.000001'))) res = json_encode({'lat': fake_lat, 'lon': fake_lon}) self.render_json(res)
def post(self): user = self.current_user do = is_value( self.get_argument("do", "add") ) tag = is_value(self.get_argument("tag", None) ) tag_page = is_value(self.get_argument("page", 'tag')) group_id = is_value( self.get_argument("group_id", '-1')) result = {'kind': -1, 'info': ''} if tag is None or len(tag) > 45: result['info'] = '分类字数需在15字以内!' self.write( json_encode(result) ) return if tag == "alltags" or tag == "default": result['info'] = '不能操作默认分类!' self.write( json_encode(result) ) return if tag_page != 'group-tag': target = user else: try: #print 'group_id', group_id group = BasicGroup(_id=group_id) if group.get_member_type(user) != 'Manager': result['info'] = '您无权进行设置!' self.write(json_encode(result)) return except Exception, e: logging.error(traceback.format_exc()) logging.error('Url Error %s' % self.request.uri) result['info'] = '小组不存在!' self.write(json_encode(result)) return else:
def post(self): params = {} resp = {KEY.STATUS: 500} params = utils.decode_params(self.request) if KEY.ID not in params or KEY.EVENT_ID not in params or KEY.USER_ID not in params or KEY.VALUE not in params: self.write(json_encode(resp)) return '''trans the term's type''' params[KEY.ID] = int(params[KEY.ID]) params[KEY.EVENT_ID] = int(params[KEY.EVENT_ID]) params[KEY.USER_ID] = int(params[KEY.USER_ID]) params[KEY.VALUE] = float(params[KEY.VALUE]) flag = db.evaluate_user(params) if flag: '''we can import here, use some algorithm to incease the helper's reputation''' user = db.get_user_information({KEY.ID: params[KEY.USER_ID]}) if user is not None: reputation = user[KEY.REPUTATION] params[KEY.VALUE] = reputation*(1 - VALUE.RATE) + VALUE.RATE*params[KEY.VALUE] if db.update_user({KEY.ID: params[KEY.USER_ID], KEY.REPUTATION: params[KEY.VALUE]}): resp[KEY.STATUS] = 200 self.write(json_encode(resp))
def get(self): word = self.get_argument('word') word = word.encode('utf_8') c = redis.Redis(host='127.0.0.1', port=6379, db=0) tag = c.exists(word) #c = database.AsyncRedis.client() #tag = yield c.async.exists(word) if tag: #value = yield c.async.zrange("%s"%word, 0, -1, False) value = c.zrange(word, 0, -1) #c.zincrby(word, value, 1) data = [] value = eval(value[0]) for li in value: songname = li[2] singer = li[3] album = li[-1] url = "commdown('" + "','".join(li) + "');" result = {} result['songname'] = songname result['singer'] = singer result['album'] = album result['from'] = "kuwo" result['url'] = url data.append(result) json = {"result":data} self.write(json_encode(json)) #self.write(json_encode(json)) else: self.write(json_encode(''))
def post(self): user = self.current_user result = {'kind':1, 'info':''} follow_id = is_value(self.get_argument("id", None)) do = is_value(self.get_argument("do", 'follow')) follow_type = is_value(self.get_argument("follow_type", 'author')) if follow_id is None or do not in ['follow', 'unfollow'] or follow_id == str(user._id): result['info'] = '参数错误!' self.write(json_encode(result)) return if follow_type != 'group': try: follower = User(_id=follow_id) except Exception, e: logging.error('User is not exist, in AuthorDoFollowHandler, user id: %s' % follow_id) result['info'] = '该用户不存在!' self.write(json_encode(result)) return else: if do == "follow": user.follow_user(follower) result['kind'] = 0 elif do == "unfollow": user.unfollow_user(follower) result['kind'] = 0 self.write(json_encode(result)) return
def on_message(self, m): try: self._broadcast(m) m = json_decode(m) logging.info(m) if m['method'] == 'getScore': package = self._getScore() if package: self.send(json_encode(package)) return elif m['method'] == 'addNote': package = self._addNote(m['note']) elif m['method'] == 'removeNote': package = self._removeNote(m['note']) elif m['method'] == 'updateNote': package = self._updateNote(m['old_note'], m['new_note']) elif m['method'] == 'addMeasureBlock': package = self._addMeasureBlock(m['measureBlock']) elif m['method'] == 'removeMeasureBlock': package = self._removeMeasureBlock(m['measureBlock']) elif m['method'] == 'clearScore': package = self._clearScore() else: raise ValueError("Didn't specify valid method") except Exception, e: logging.error(traceback.print_exc()) self.send(json_encode("Python exception: %s" % str(e)))
def post(self): params = {} resp = {KEY.STATUS: 500} params = utils.decode_params(self.request) if KEY.EVENT_ID not in params: self.write(json_encode(resp)) return '''trans the term's type''' params[KEY.EVENT_ID] = int(params[KEY.EVENT_ID]) supporter_ids = db.list_support_relation(params) print supporter_ids if supporter_ids is not None: supporter_info = [] for item in supporter_ids: user_info = db.get_user_information({KEY.ID: item}) if user_info is not None: user = {} user[KEY.ID] = user_info[KEY.ID] user[KEY.NICKNAME] = user_info[KEY.NICKNAME] user[KEY.NAME] = user_info[KEY.NAME] user[KEY.OCCUPATION] = user_info[KEY.OCCUPATION] user[KEY.REPUTATION] = user_info[KEY.REPUTATION] user[KEY.LOCATION] = user_info[KEY.LOCATION] user[KEY.IS_VERIFY] = user_info[KEY.IS_VERIFY] user[KEY.GENDER] = user_info[KEY.GENDER] supporter_info.append(user) resp[KEY.STATUS] = 200 resp[KEY.INFO] = supporter_info self.write(json_encode(resp))
def get(self): uri_hash_code= hashlib.md5(self.request.uri).hexdigest() res = self.redis_client.get('String:' + uri_hash_code) if res: return self.finish(res) urls = self.get_argument('urls', '') start = self.get_argument('start', '') end = self.get_argument('end', '') need_query = [] task_list = json_decode(urls) for task in task_list: mark = task['url'] + '@' + task['host'] task_id = self.redis_client.hget('Hash:Tan14TaskId', mark) if not task_id: task_id = self.mdb['TaskList'].find_one({'task_target': task['url'], 'http_proxy': task['host'] + ':80'}, {'task_id':1, '_id': 0}) if task_id: need_query.append(task_id) else: task_id = self.add_task(task) if task_id: self.redis_client.hset('Hash:Tan14TaskId', mark, task_id) if need_query: cursor = self.mdb['Result'].find({'task_id': {'$in': need_query}, 'record_time': {'$gt': int(start), '$lt': int(end)}}, {'_id': 0, 'task_id': 1, 'http_code': 1, 'connect_time': 1, 'record_time': 1}).sort([('record_time', 1)]) if cursor.count() != 0: a, b = self.merge_data(list(cursor)) retval = self.gen_retval(0, a, b) self.redis_client.set('String:'+ uri_hash_code, json_encode(retval)) self.redis_client.expire('String:'+uri_hash_code, 24 * 3600) else: retval = self.gen_retval(1, a=[], b=[]) else: retval = self.gen_retval(1, a=[], b=[]) self.write(json_encode(retval))
def get(self, *args): url = self.get_argument('url') response = yield fetch_webpage(url) if response.body: (bookmark, webpage) = self.bm.refresh_by_goose(url, html=response.body) else: print("Error:", response.error) self.write(json_encode({'success': 'false'})) # 默认使用readability的parser API # 教程: http://www.readability.com/developers/api/parser # try: # http_client = tornado.httpclient.AsyncHTTPClient() # response = yield http_client.fetch("https://readability.com/api/content/v1/parser?token=7f579fc61973e200632c9e43ff2639234817fbb3&url=" + tornado.escape.url_escape(url)) # if response.body: # (bookmark, webpage) = self.bm.refresh_by_readability(url, readability=response.body) # except tornado.httpclient.HTTPError: # # print("Error:", response.error) # # 备用,处理readability无法识别的网页 # response = yield fetch_webpage(url) # if response.body: # (bookmark, webpage) = self.bm.refresh_by_html(url, html=response.body) # else: # print("Error:", response.error) # self.write(json_encode({'success': 'false'})) if bookmark: bookmark_module = tornado.escape.to_basestring( self.render_string('modules/bookmark.html', bookmark=bookmark)) self.write(json_encode({ 'success': 'true', 'bookmark_module': bookmark_module, 'title': bookmark['title'], 'article': tornado.escape.to_basestring(webpage['content']) })) else: self.write(json_encode({'success': 'false'}))
def get(self, user_id): try: user_id = user_id.replace('.json', '') news_feed = [] for row in self.db_stories.view('stories/by_user_id', key=user_id, include_docs="true", descending="true", limit=10): story = row.doc story['story_id'] = story['_id'] del story['_id'] del story['_rev'] del story['session_id'] if 'media_name' not in story: m = re.match('https\:\/\/.+amazonaws\.com\/(.+)\/(.+)', story['media_url']) if m is not None: story['media_bucket'] = m.group(1) story['media_name'] = m.group(2) news_feed.append(story) self.write(json_encode({"news_feed":{ "response": "true", "status": "success", "news_feed": news_feed, }})) except Exception: self.write(json_encode({"news_feed":{ "response": "false", "status": "internal error", "traceback": traceback.format_exc() }}))
def post(self): """Add a facility.""" global compressed_facilities if not revisit_online: raise tornado.web.HTTPError(502) new_facility = json_decode(self.request.body) c_facilities_json = json_decode(compressed_facilities) facility_data = ( c_facilities_json['facilities']['children']['wn']['data'][0] ) uncompressed = json_decode(lzs.decompressFromUTF16(facility_data)) uncompressed.append({ '_version': 0, 'active': True, 'coordinates': new_facility['coordinates'], 'createdAt': '2014-04-23T20:32:20.043Z', 'href': ( 'http://localhost:3000/api/v0/facilities/{}.json'.format( new_facility['uuid'] ) ), 'identifiers': [], 'name': new_facility['name'], 'properties': new_facility['properties'], 'updatedAt': '2014-04-23T20:32:20.043Z', 'uuid': new_facility['uuid'], }) compressed = lzs.compressToUTF16(json_encode(uncompressed)) c_facilities_json['facilities']['children']['wn']['data'] = [ compressed ] compressed_facilities = json_encode(c_facilities_json).encode() self.set_status(201)
def post(self): category_id = int(self.get_argument('category_id', 0)) title = self.get_argument('title', '') content = self.get_argument('content', '') create_uid = self.get_secure_cookie('admin_user_id') status = int(self.get_argument('status', 0)) if not category_id: response = {'code': 110, 'msg': self.error_message['110']} return self.write(json_encode(response)) if not title: response = {'code': 111, 'msg': self.error_message['111']} return self.write(json_encode(response)) if not content: response = {'code': 112, 'msg': self.error_message['112']} return self.write(json_encode(response)) result = News.new(category_id, title, content, create_uid, status) if result: response = {'code': 0, 'msg': '添加成功'} return self.write(json_encode(response)) else: response = {'code': 114, 'msg': self.error_message['114']} return self.write(json_encode(response))
def post(self): params = {} resp = {KEY.STATUS: 500} params = utils.decode_params(self.request) if KEY.EVENT_ID not in params: self.write(json_encode(resp)) return '''trans the term's type''' params[KEY.EVENT_ID] = int(params[KEY.EVENT_ID]) launcher_info = db.get_event_information(params) if launcher_info is not None: user_info = db.get_user_information({KEY.ID: launcher_info[KEY.LAUNCHER_ID]}) if user_info is not None: resp[KEY.STATUS] = 200 resp[KEY.ID] = user_info[KEY.ID] resp[KEY.NICKNAME] = user_info[KEY.NICKNAME] resp[KEY.NAME] = user_info[KEY.NAME] resp[KEY.AGE] = user_info[KEY.AGE] resp[KEY.GENDER] = user_info[KEY.GENDER] resp[KEY.PHONE] = user_info[KEY.PHONE] resp[KEY.OCCUPATION] = user_info[KEY.OCCUPATION] resp[KEY.REPUTATION] = user_info[KEY.REPUTATION] resp[KEY.LOCATION] = user_info[KEY.LOCATION] resp[KEY.IS_VERIFY] = user_info[KEY.IS_VERIFY] self.write(json_encode(resp))
def get_valid_locate_or_isp(self, kind = None): """ 获取当前可用地区列表 从locate_mgr获取可用地区列表 查询RegisteredLocate,获取详细信息 { "info" : { "data" : { "region_id" : "310000", "region" : "上海市", "isp" : "电信", "isp_id" : "100017" } } } """ if kind in ('region', 'isp'): valid_locate = self.loct_mgr.get_valid_locate() if valid_locate: try: cursor = self.mdb['RegisteredSlave'].find({'locate_key': {'$in': valid_locate}}, {'_id' : 0, 'ip_info.data.' + kind : 1, 'ip_info.data.' + kind +'_id': 1 }) except TypeError: return self.write(json_encode({'code': 1, 'data': '数据库查询参数错误'})) retval = [] tmp = {} for res in cursor: tmp.setdefault(res['ip_info']['data'][kind], res['ip_info']['data'][kind + '_id']) for locate_name, locate_key in tmp.iteritems(): retval.append({locate_name: locate_key}) self.write(json_encode({'code': 0, 'data': retval})) else: self.write(json_encode({'code': 1, 'data': '当前没有信息'})) else: raise AssertionError('kind参数只能取值region或isp')
def post(self): params = {} resp = {KEY.STATUS: 500} params = utils.decode_params(self.request) if KEY.LONGITUDE not in params or KEY.LATITUDE not in params: self.write(json_encode(resp)) return '''trans the term's type''' params[KEY.LONGITUDE] = float(params[KEY.LONGITUDE]) params[KEY.LATITUDE] = float(params[KEY.LATITUDE]) params[KEY.STATE] = 0 event_id_list = db.get_nearby_event_by_location(params) if event_id_list is not None: event_list = [] for item in event_id_list: event_info = db.get_event_information({KEY.EVENT_ID: item}) if event_info is not None: event_temp = {} event_temp[KEY.EVENT_ID] = event_info[KEY.EVENT_ID] event_temp[KEY.TYPE] = event_info[KEY.TYPE] event_temp[KEY.LONGITUDE] = event_info[KEY.LONGITUDE] event_temp[KEY.LATITUDE] = event_info[KEY.LATITUDE] event_list.append(event_temp) resp[KEY.STATUS] = 200 resp[KEY.INFO] = event_list self.write(json_encode(resp))
def get(self, *args): ''' deneme 2 :param args: :return: ''' (friends_or_followers) = args queue_collection = self.application.db.motor_column.queue # Get the N'th most frequent visited one N = 100 if friends_or_followers == 'followers': cur = queue_collection.find({"protected": {"$ne": True}}).sort('followers_retrieved_at', -1).limit(N) else: cur = queue_collection.find({"protected": {"$ne": True}}).sort('friends_retrieved_at', -1).limit(N) a = [] for c in (yield cur.to_list(length=100)): a.append(c["id"]) # print c idx = random.randint(0, N - 1) # TODO: Needs redesign, current strategy too naive if len(a) == 0: self.write(json_encode(0)) print "Suggest ToGet %s : User %d " % (friends_or_followers, 0) else: self.write(json_encode(a[idx])) print "Suggest ToGet %s : User %d " % (friends_or_followers, a[-1])
def post(self): params = {} resp = {KEY.STATUS: 500} params = utils.decode_params(self.request) if KEY.ID not in params or KEY.EVENT_ID not in params or KEY.LAUNCHER_ID not in params or KEY.TYPE not in params: self.write(json_encode(resp)) return '''trans the term's type''' params[KEY.ID] = int(params[KEY.ID]) params[KEY.EVENT_ID] = int(params[KEY.EVENT_ID]) params[KEY.LAUNCHER_ID] = int(params[KEY.LAUNCHER_ID]) params[KEY.TYPE] = int(params[KEY.TYPE]) flag = db.add_support_relation(params) if flag >= 0: resp[KEY.STATUS] = 200 '''send notification to supportee, someone is coming to help him''' launcher_info = db.get_user_information({KEY.ID: params[KEY.LAUNCHER_ID]}) launcher_info = utils.trans_unicode_to_utf(launcher_info) if launcher_info is not None: if params[KEY.TYPE] == 2: mess = sendHelp.buildMessage(type=1, title=title, content=content, style=xinge.Style(0, 0, 0, 1, 2)) sendHelp.sendEhelp(header + launcher_info[KEY.NICKNAME], mess) if params[KEY.TYPE] == 1: mess = sendHelp.buildMessage(type=1, title=title, content=content, style=xinge.Style(0, 0, 0, 0, 5)) sendHelp.sendEhelp(header + launcher_info[KEY.NICKNAME], mess) self.write(json_encode(resp))
def async_get(self, mapnik_map): try: layer = self.layer_by_id(mapnik_map, self.layer_id) field_values = [dict(f).get(self.field_name) for f in layer.datasource.all_features()] start = 0 + int(self.get_argument("start", 0)) end = int(self.get_argument("limit", 30)) + int(self.get_argument("start", 0)) stringlen = {"key": len} if isinstance(field_values[0], basestring) else {} json = json_encode( { "min": min(field_values, **stringlen), "max": max(field_values, **stringlen), "count": len(set(field_values)), "field": self.field_name, "values": sorted(list(set(field_values)))[start:end], } ) self.jsonp(json, self.get_argument("jsoncallback", None)) except IndexError: self.jsonp({"error": "Layer not found"}, self.get_argument("jsoncallback", None)) except Exception, e: self.jsonp(json_encode({"error": "Exception: %s" % e}), self.get_argument("jsoncallback", None))
def get(self, *args): ''' deneme :param args: :return: ''' (num) = args queue_collection = self.application.db.motor_column.queue print num # if N>100: N = 100 # TODO: Needs redesign, current strategy too naive cur = queue_collection.find({"protected": False}).sort('profile_retrieved_at', 1).limit(N) a = [] for c in (yield cur.to_list(length=100)): a.append(c["id_str"]) # print c # idx = random.randint(0, N-1) if len(a) == 0: self.write(json_encode(0)) else: self.write(json_encode(a)) print a
def post(self): params = {} resp = {KEY.STATUS: 500} params = utils.decode_params(self.request) if KEY.EVENT_ID not in params: self.write(json_encode(resp)) return '''trans the term's type''' params[KEY.EVENT_ID] = int(params[KEY.EVENT_ID]) event_info = db.get_event_information(params) if event_info is not None: resp[KEY.STATUS] = 200 resp[KEY.LAUNCHER_ID] = event_info[KEY.LAUNCHER_ID] resp[KEY.TIME] = event_info[KEY.TIME] resp[KEY.TYPE] = int(event_info[KEY.TYPE]) resp[KEY.SUPPORT_NUMBER] = event_info[KEY.SUPPORT_NUMBER] resp[KEY.DEMAND_NUMBER] = event_info[KEY.DEMAND_NUMBER] resp[KEY.LONGITUDE] = event_info[KEY.LONGITUDE] resp[KEY.LATITUDE] = event_info[KEY.LATITUDE] resp[KEY.LAUNCHER_NAME] = event_info[KEY.LAUNCHER] user = db.get_user_information({KEY.ID: resp[KEY.LAUNCHER_ID]}) if user is not None: resp[KEY.CONTACT] = user[KEY.PHONE] '''if this event is help''' if resp[KEY.TYPE] == 1: resp[KEY.TITLE] = event_info[KEY.TITLE] resp[KEY.CONTENT] = event_info[KEY.CONTENT] resp[KEY.LOVE_COIN] = int(event_info[KEY.LOVE_COIN]) self.write(json_encode(resp))
def _on_notify_response(self, data, error): if data: self.write(json_encode(data)) else: self.write(json_encode("")) self.finish()
def post(self): user_id = int(self.get_argument('id', 0)) username = self.get_argument('username', '') password = self.get_argument('password', '') email = self.get_argument('email', '') realname = self.get_argument('realname', '') role_id = int(self.get_argument('role_id', 0)) match = re.search(r'[\w.-]+@[\w.-]+', email) if not match: ret = {'code': 112, 'msg': self.error_message['112']} return self.write(json_encode(ret)) if not role_id: ret = {'code': 113, 'msg': self.error_message['113']} return self.write(json_encode(ret)) result = User.update(user_id, username, email, password, realname, role_id) if result: ret = {'code': 0, 'msg': '更新成功'} return self.write(json_encode(ret)) else: ret = {'code': 114, 'msg': self.error_message['114']} return self.write(json_encode(ret))
def post(self): data = self.request.arguments print data timekey= data['timekey'][0] s_file_path=data['s_file_path'][0] filename=s_file_path.split('/')[-1] copyinfo=None if "salt://files/" not in s_file_path: print "not in salt://" if os.path.exists(s_file_path): #如果filse目录不存在则创建 if not os.path.exists('/srv/salt/files'): os.makedirs('/srv/salt/files') #复制源文件到salt的files目录 shutil.copyfile(s_file_path,"/srv/salt/files/%s" %filename) else: print "no" copyinfo= "%s is not exist" % s_file_path print copyinfo d_file_path=data['d_file_path'][0] if not data['devsarr']: ress={"status":1,"value":"no devs!"} self.write(json_encode(ress)) #循环设备 for devid in data['devsarr']: info = db.query('select * from host_devs where id='+devid)[0] print info ip = info['ip'] print "ip:"+ip pushfiletask.delay(copyinfo, timekey, ip, filename, s_file_path, d_file_path) ress={"status":0,"value":"提交任务成功"} self.write(json_encode(ress))
async def post(self): try: args = RouteInputSchema().load( escape.json_decode(self.request.body)) except ValidationError as e: raise web.HTTPError(400, escape.json_encode(e.messages), e.messages) route_id = uuid.uuid4() data = args.data new_route = Route( id=str(route_id), origin=func.ST_GeomFromGeoJSON(escape.json_encode(data['origin'])), origin_name=data['origin_name'], destination=func.ST_GeomFromGeoJSON( escape.json_encode(data['destination'])), destination_name=data['destination_name'], polyline=func.ST_GeomFromGeoJSON(escape.json_encode(data['polyline'])), bounds=data.get('bounds'), created=data.get('created') or datetime.utcnow() ) self.db.add(new_route) self.db.commit() new_route_from_db = self._route_query().filter( Route.id == str(route_id)).one() schema = RouteOutputSchema() output = schema.dumps(row_to_dict(new_route_from_db)) self.finish(output.data)
def post(self): data = self.request.arguments print "提交上来的内容"+str(data) #print data['shellname'][0] shellcontent = data['shellcontent'][0] shelltype = data['shelltype'][0] timekey= data['timekey'][0] if not timekey: self.write('no timestamp') #根据脚本类型定脚本后缀名称 scriptname="run.sh" if shelltype=="pyhon": scriptname="run.py" file_object = open("/srv/salt/scripts/%s" % scriptname,"w") file_object.write(shellcontent) file_object.close() os.popen('dos2unix /srv/salt/scripts/%s' % scriptname) if not data.has_key('devsarr'): ress={"status":1,"value":"no devs"} self.write(json_encode(ress)) return #循环设备 for devid in data['devsarr']: #print i info = db.query('select * from host_devs where id='+devid)[0] print info ip = info['ip'] print "ip:"+ip #port=info['port'] #user = info['user'] #passwd = info['passwd'] commandtask.delay(timekey,ip,scriptname) ress={"status":0,"value":"任务已提交"} self.write(json_encode(ress))
def get(self, structure_id): print "structure id", structure_id if db[PDB_STR_COL_NAME].find_one({"structure_id": structure_id}) == None: from crawler import download_pdb_file pdb_str = download_pdb_file(structure_id) if pdb_str is None: #pdb id not found, return 500 code self.set_status(500) self.write(json_encode({ "pdb_id": structure_id, "status":"not found" })) else: #find one from pdb bank db[PDB_STR_COL_NAME].insert({ "structure_id": structure_id, "content": pdb_str }) self.write(json_encode({ "pdb_id": structure_id, "status":"inserted" })) else: #it just exists in our db self.write(json_encode({ "pdb_id": structure_id, "status":"exist" }))
def post(self): params = {} resp = {KEY.STATUS: 500} params = utils.decode_params(self.request) if KEY.ID not in params or KEY.LAUNCHER_ID not in params or KEY.TYPE not in params or KEY.EVENT_ID not in params: self.write(json_encode(resp)) return '''trans the term's type''' params[KEY.EVENT_ID] = int(params[KEY.EVENT_ID]) params[KEY.ID] = int(params[KEY.ID]) params[KEY.LAUNCHER_ID] = int(params[KEY.LAUNCHER_ID]) params[KEY.TYPE] = int(params[KEY.TYPE]) flag = db.remove_support_relation(params) if flag: '''when the event is help or emergence, it is necessary to notify the users''' user_info = db.get_user_information({KEY.ID: params[KEY.LAUNCHER_ID]}) user_info = utils.trans_unicode_to_utf(user_info) if user_info is not None: if params[KEY.TYPE] == 2: mess = sendHelp.buildMessage(type=1, title=title, content=content, style=xinge.Style(0, 0, 0, 1, 3)) sendHelp.sendEhelp(header + user_info[KEY.NICKNAME], mess) if params[KEY.TYPE] == 1: mess = sendHelp.buildMessage(type=1, title=title, content=content, style=xinge.Style(0, 0, 0, 0, 6)) sendHelp.sendEhelp(header + user_info[KEY.NICKNAME], mess) resp[KEY.STATUS] = 200 self.write(json_encode(resp))
def application_id(self) -> ObjectId: raw_application_id = self.handler.get_argument("application_id", None) if raw_application_id is None: self.handler.set_status(428, "missing param(s) application_id") self.handler.finish( json_encode( { "status": "error", "message": "missing param(s) application_id" } ) ) raise Finish() try: return ObjectId(raw_application_id) except InvalidId: self.handler.set_status(412) self.handler.finish( json_encode( { "status": "error", "message": "invalid param=application_id,application_id=%s" % raw_application_id } ) ) raise Finish()
def sign_person_in(self, user): """ If we’ve seen the user before, update their info, otherwise create a brand new user record and set their cookie. """ e_user = self.db.get("SELECT * FROM user WHERE twitter_id = %s", user['id']) print "post here" if e_user: self.db.execute("""UPDATE user SET name=%s, screen_name=%s, description=%s, location=%s, url=%s, profile_image_url=%s, time_zone=%s, access_token=%s, updated_at=NOW() WHERE twitter_id = %s""", user['name'], user['username'], user['description'], user['location'], user['url'], user['profile_image_url'], user['time_zone'], json_encode(user['access_token']),e_user['twitter_id']) else: self.db.execute("""INSERT INTO user ( twitter_id, name, screen_name, description, location, url, profile_image_url, time_zone, access_token, created_at, updated_at) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, NOW(), NOW())""", user['id'], user['name'], user['username'], user['description'], user['location'], user['url'], user['profile_image_url'], user['time_zone'], json_encode(user['access_token'])) pid = {'id':user['id'], 'name':user['name'], 'username':user['username']} self.set_secure_cookie("pid", tornado.escape.json_encode(pid), expires_days=365)
def post(self): try: request = json_decode(self.request.body) req_type = "" if "type" in request.keys(): req_type = request["type"] if not req_type: self.write_error(406) return if req_type == "wiki": wiki_link = "" if "link" in request.keys(): wiki_link = request["link"] if not core.utils.internet.internet.is_valid_url(wiki_link) or \ not wiki_link.startswith("https://en.wikipedia.org/wiki/"): self.write_error(400) return all_links = wikilm.WikiLinkMaker.make_links_from_link(wiki_link) self.set_header("Content-Type", "application/json") self.write(json_encode(all_links)) else: self.set_header("Content-Type", "application/json") self.write(json_encode("Oops!")) except Exception as e: self.set_header("Content-Type", "application/json") self.write("Error: " + json_encode(str(e)))
try: last_time = time.localtime(float(repeat)) current_time = time.localtime() except Exception, e: logging.error(traceback.format_exc()) result['info'] = '参数错误!' self.set_cookie("repeat", str(time.time())) self.write(json_encode(result)) return else: tmp1 = datetime(*last_time[:6]) tmp2 = datetime(*current_time[:6]) tmp3 = tmp2 - tmp1 if tmp3.seconds < 30: result['info'] = '时间有误!' self.set_cookie("repeat", str(time.time())) self.write(json_encode(result)) return result['kind'], result['info'] = fun_repeat_mail(email.lower()) self.set_cookie("repeat", str(time.time())) self.write(json_encode(result)) return class InviteHandler(BaseHandler): @authfilter def get(self): return self.render("user-invite.html",title="子曰--邀请注册",user=self.current_user)
def edit_show(show, any_qualities, best_qualities, exceptions_list, location=None, flatten_folders=None, paused=None, direct_call=None, air_by_date=None, sports=None, dvdorder=None, indexer_lang=None, subtitles=None, sub_use_sr_metadata=None, skip_downloaded=None, rls_ignore_words=None, rls_require_words=None, anime=None, blacklist=None, whitelist=None, scene=None, default_ep_status=None, quality_preset=None, search_delay=None, session=None): show_obj = find_show(int(show), session=session) if not show_obj: err_msg = _("Unable to find the specified show: ") + str(show) if direct_call: sickrage.app.alerts.error(_('Error'), err_msg) return False, err_msg show_obj.exceptions = get_scene_exceptions(show_obj.indexer_id) flatten_folders = not checkbox_to_value(flatten_folders) # UI inverts this value dvdorder = checkbox_to_value(dvdorder) skip_downloaded = checkbox_to_value(skip_downloaded) paused = checkbox_to_value(paused) air_by_date = checkbox_to_value(air_by_date) scene = checkbox_to_value(scene) sports = checkbox_to_value(sports) anime = checkbox_to_value(anime) subtitles = checkbox_to_value(subtitles) sub_use_sr_metadata = checkbox_to_value(sub_use_sr_metadata) if indexer_lang and indexer_lang in IndexerApi(show_obj.indexer).indexer().languages.keys(): indexer_lang = indexer_lang else: indexer_lang = show_obj.lang # if we changed the language then kick off an update if indexer_lang == show_obj.lang: do_update = False else: do_update = True if scene == show_obj.scene or anime == show_obj.anime: do_update_scene_numbering = False else: do_update_scene_numbering = True show_obj.paused = paused show_obj.scene = scene show_obj.anime = anime show_obj.sports = sports show_obj.subtitles = subtitles show_obj.sub_use_sr_metadata = sub_use_sr_metadata show_obj.air_by_date = air_by_date show_obj.default_ep_status = int(default_ep_status) show_obj.skip_downloaded = skip_downloaded # If directCall from mass_edit_update no scene exceptions handling or blackandwhite list handling if direct_call: do_update_exceptions = False else: if set(exceptions_list) == set(show_obj.exceptions): do_update_exceptions = False else: do_update_exceptions = True if anime: if whitelist: shortwhitelist = short_group_names(whitelist) show_obj.release_groups.set_white_keywords(shortwhitelist) else: show_obj.release_groups.set_white_keywords([]) if blacklist: shortblacklist = short_group_names(blacklist) show_obj.release_groups.set_black_keywords(shortblacklist) else: show_obj.release_groups.set_black_keywords([]) warnings, errors = [], [] new_quality = try_int(quality_preset, None) if not new_quality: new_quality = Quality.combine_qualities(list(map(int, any_qualities)), list(map(int, best_qualities))) show_obj.quality = new_quality # reversed for now if bool(show_obj.flatten_folders) != bool(flatten_folders): show_obj.flatten_folders = flatten_folders try: sickrage.app.show_queue.refresh_show(show_obj.indexer_id, True) except CantRefreshShowException as e: errors.append(_("Unable to refresh this show: {}").format(e)) if not direct_call: show_obj.lang = indexer_lang show_obj.dvdorder = dvdorder show_obj.rls_ignore_words = rls_ignore_words.strip() show_obj.rls_require_words = rls_require_words.strip() show_obj.search_delay = int(search_delay) # if we change location clear the db of episodes, change it, write to db, and rescan if os.path.normpath(show_obj.location) != os.path.normpath(location): sickrage.app.log.debug(os.path.normpath(show_obj.location) + " != " + os.path.normpath(location)) if not os.path.isdir(location) and not sickrage.app.config.create_missing_show_dirs: warnings.append("New location {} does not exist".format(location)) # don't bother if we're going to update anyway elif not do_update: # change it try: show_obj.location = location try: sickrage.app.show_queue.refresh_show(show_obj.indexer_id, True) except CantRefreshShowException as e: errors.append(_("Unable to refresh this show:{}").format(e)) # grab updated info from TVDB # showObj.loadEpisodesFromIndexer() # rescan the episodes in the new folder except NoNFOException: warnings.append( _("The folder at %s doesn't contain a tvshow.nfo - copy your files to that folder before " "you change the directory in SiCKRAGE.") % location) # force the update if do_update: try: sickrage.app.show_queue.update_show(show_obj.indexer_id, force=True) except CantUpdateShowException as e: errors.append(_("Unable to update show: {}").format(e)) if do_update_exceptions: try: update_scene_exceptions(show_obj.indexer_id, exceptions_list) except CantUpdateShowException: warnings.append(_("Unable to force an update on scene exceptions of the show.")) if do_update_scene_numbering: try: xem_refresh(show_obj.indexer_id, show_obj.indexer, True) except CantUpdateShowException: warnings.append(_("Unable to force an update on scene numbering of the show.")) if direct_call: return True if len(warnings) == 0 and len(errors) == 0 else False, json_encode({'warnings': warnings, 'errors': errors}) if len(warnings) > 0: sickrage.app.alerts.message( _('{num_warnings:d} warning{plural} while saving changes:').format(num_warnings=len(warnings), plural="" if len( warnings) == 1 else "s"), '<ul>' + '\n'.join(['<li>{0}</li>'.format(warning) for warning in warnings]) + "</ul>") if len(errors) > 0: sickrage.app.alerts.error( _('{num_errors:d} error{plural} while saving changes:').format(num_errors=len(errors), plural="" if len(errors) == 1 else "s"), '<ul>' + '\n'.join(['<li>{0}</li>'.format(error) for error in errors]) + "</ul>") return True, ""
def queue_message(self, msg, **data): data["msg"] = msg if not self.client_closed: self.write_message(json_encode(data), False)
def send_message(self, msg, **data): """Sends a JSON message to the client.""" data["msg"] = msg if not self.client_closed: self.write_message(json_encode(data))
def get(self): users = UserModel.get_users_by_merchant_id( self.db, self.current_user.merchant_id) self.render("userManage.html", users=json_encode([user.todict() for user in users]))
def test_post_library_pool_process_handler(self): # Amplicon test data = { 'plates-info': json_encode([{ 'plate-id': 23, 'pool-func': 'amplicon', 'dna-amount-23': 240, 'min-val-23': 1, 'max-val-23': 15, 'blank-val-23': 2, 'epmotion-23': 10, 'dest-tube-23': 1 }]) } response = self.post('/process/poollibraries', data) self.assertEqual(response.code, 200) obs = json_decode(response.body) self.assertEqual(len(obs), 1) self.assertCountEqual(obs[0], ['plate-id', 'process-id']) # Shotgun test data = { 'plates-info': json_encode([{ 'plate-id': 26, 'pool-func': 'equal', 'volume-26': 200, 'lib-size-26': 500 }]) } response = self.post('/process/poollibraries', data) self.assertEqual(response.code, 200) obs = json_decode(response.body) self.assertEqual(len(obs), 1) self.assertCountEqual(obs[0], ['plate-id', 'process-id']) # Failure amplicon data = { 'plates-info': json_encode([{ 'plate-id': 23, 'pool-func': 'amplicon', 'dna-amount-23': 240, 'min-val-23': 1, 'max-val-23': 15, 'blank-val-23': 2, 'epmotion-23': 10 }]) } response = self.post('/process/poollibraries', data) self.assertEqual(response.code, 400) # Failure shotgun data = { 'plates-info': json_encode([{ 'plate-id': 26, 'pool-func': 'equal', 'volume-26': 200 }]) } response = self.post('/process/poollibraries', data) self.assertEqual(response.code, 400)
def send_message_to_client(self, message): self.write_message(json_encode(message))
def content_json(self): if not self._content_json: self._content_json = json_encode(self.content) return self._content_json
def get(self, _): # self.set_statues(404) self.write(json_encode(result_utils.error('20009')))
def metadata_json(self): if not self._metadata_json: self._metadata_json = json_encode(self.metadata) return self._metadata_json
async def post(self): class RequestSchema(Schema): date = fields.Date(required=True) RequestSchema().loads(self.request.body) self.write(json_encode({"test": "ok"}))
def header_json(self): if not self._header_json: self._header_json = json_encode(self.header) return self._header_json
def write_error(self, status_code: int, **kwargs: Any) -> None: code, data = handle_error(kwargs["exc_info"][1], processor) self.set_status(code) self.write(json_encode(data)) return
def send_message(self, *args, **kwargs): callback = kwargs.get('callback', None) data = kwargs.get('data', None) logger.debug(data) # Catch invalid recipient if data['recipient'] not in self.connections: error = 'Connection "'+data['recipient']+'" not found' logger.error(error) error = { 'message': error } if (callback): callback(False, error) else: return error # Sending of an error if 'error' in data: message = { 'jsonrpc': '2.0', 'error': data['error'] } # Sending of a regular message else: message = { 'jsonrpc': '2.0', 'method': data['method'] if 'method' in data else None } if 'id' in data: message['id'] = data['id'] if 'params' in data: message['params'] = data['params'] if 'result' in data: message['result'] = data['result'] # Dispatch the message try: self.connections[data['recipient']]['connection'].write_message(json_encode(message)) response = { 'message': 'Sent message to '+data['recipient'] } if (callback): callback(response) else: return response except: error = 'Failed to send message to '+ data['recipient'] logger.error(error) error = { 'message': error } if (callback): callback(False, error) else: return error
def post(self): """ jobid: jobname: status: message: [] :return: """ body = json_decode(self.request.body) job_id = body.get('jobid', '') task_id = body.get('taskid', '') task_name = body.get('jobname', '') task_status = body.get('status', '') task_message = body.get('messages', []) if job_id == '' or task_name == '' or task_status == '' or task_message == []: res = { "status": JobCallbackResponseStatus.fail.value, "message": "some argument is null" } logger.error( "job callback fail: {}".format("some argument is null")) self.write(json.dumps(res)) self.finish() else: logger.info( 'Job_ID: {}, Task_id: {}, Job_Step: {}, Task_Status: {}'. format(job_id, task_id, task_name, task_status)) zk = self.application.zk if zk.update_callback_by_taskid(job_id, task_id, task_status, task_message): logger.info( "update callback by taskid sucess: jobid={}, taskid={}". format(job_id, task_id)) else: logger.error( "update callback by taskid failed: jobid={}, taskid={}". format(job_id, task_id)) for message in task_message: logger.info('"Host": {}, "status": {}, "message": {}'.format( message['host'], message['status'], message['message'])) if zk.handler_task(job_id, task_id, task_name, task_message, task_status): logger.info("handler task success after callback") if zk.is_exist_signal(job_id): zk.send_signal(job_id) res = { "status": JobCallbackResponseStatus.success.value, "message": "callback receive success, and handler task success after callback" } else: logger.error("handler task fail after callback") res = { "status": JobCallbackResponseStatus.success.value, "message": "callback receive success, but handler task fail after callback" } self.write(json_encode(res)) self.finish()
async def get(self): self.write(json_encode({"test": "ok"}))
def get(self): users = UserModel.get_all() self.write(json_encode(users))
def get(self, *args, **kwargs): codes = [{"id": code, "name": Subtitles().name_from_code(code)} for code in Subtitles().subtitle_code_filter()] codes = list(filter(lambda code: code['id'] in Subtitles().wanted_languages(), codes)) return self.write(json_encode(codes))
def update_clients(self): json_status = json_encode(self.get_status()) for client in clients: client.write_message(json_status)
def post(self): name = self.get_argument('name') age = self.get_argument('age') UserModel.create(name, age) resp = {'status': True, 'msg': 'create success'} self.write(json_encode(resp))
def get(self): response = Setting.gets() return self.write(json_encode(response))
def update(self): json_status = json_encode(self.get_status()) self.write_message(json_status)
def message(status, content): return json_encode(dict(status_code=status, msg=content))
def on_timeout(self, num): self.time_handler = None self.send_data(json_encode({'name': '', 'msg': ''})) if (self.client.connection.connected()): self.client.disconnect()
def write_json(self, data): return self.send(escape.json_encode(data))
def error(status, content): return json_encode(dict(status_code=status, err=content))
def set_current_user(self, username): print "Set current user: "******"user", escape.json_encode(username)) else: self.clear_cookie("user")
def request(self, method, path, data=None, json=False, files=None, cookies=None, **kwgs): kwgs['method'] = method ## `path` should be utf-8 encoded string to complete requote process #if isinstance(path, str): # path = path.encode('utf8') path = requote_uri(path) # `body` must be passed if method is one of those three if method in ['POST', 'PUT', 'PATCH']: headers = kwgs.setdefault('headers', {}) body = '' if files: boundary = '1234567890' headers[ 'Content-Type'] = 'multipart/form-data; boundary=%s' % boundary L = [] if data: for k, v in data.items(): L.append('--' + boundary) L.append('Content-Disposition: form-data; name="%s"' % k) L.append('') L.append(v) for k, f in files.items(): L.append('--' + boundary) L.append( 'Content-Disposition: form-data; name="%s"; filename="%s"' % (k, f[0])) L.append('Content-Type: %s' % mimetypes.guess_type(f[0])[0] or 'application/octet-stream') L.append('') L.append(f[1]) L.append('--%s--' % boundary) L.append('') body = '\r\n'.join(L) else: if data: if json: body = json_encode(data) headers['Content-Type'] = 'application/json' else: headers[ 'Content-Type'] = 'application/x-www-form-urlencoded' body = urlencode(data) kwgs['body'] = body else: if data: path = '%s?%s' % (path, urlencode(data)) if cookies: self._add_cookies(cookies, kwgs) #print 'fetch kwgs', kwgs url = self.get_url(path) logging.debug('testing fetch url: %s', url) self.http_client.fetch(url, self.stop, **kwgs) resp = self.wait() self._parse_cookies(resp) return resp
def get(self): self.file_lister.refresh() self.set_header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0') self.set_header('Content-Type', 'application/json') self.write(escape.json_encode(self.file_lister.files))
def return_json(self, data): _json_data = json_encode(data) self.set_header("Content-Type", "application/json; charset=UTF-8") self.write(_json_data)