def lpush(self, key, value, **kwargs):
"""
LPUSH key value Append an element to the head of the List value at key
param;
key:string
value:string
**kwargs: a dict
obj:object
baseobj:base object
return:
True or False
"""
#print "listfield lpush ",key,",",value
try:
if setting.Debug:
n = datetime.datetime.now()
pipe = RedisClient.getInstance().redis.pipeline()
pipe.lpush(key, value)
self.change_log("list:insert", kwargs["obj"].id, kwargs["baseobj"],
pipe)
pipe.execute()
if setting.Debug:
logger.info(" lpush key: %s,use : %s" %
(key, datetime.datetime.now() - n))
return True
except Exception, e:
pipe.reset()
logger.error(e)
return False
def check_auth_sync(self):
try:
node_id = self.request.uri.split("?")[0]
# 查询用户属于哪些角色
role_ids = []
query = {"username": self.get_secure_cookie("user").decode('utf-8')}
show = {"_id": 0}
cursor = self.db.sys_user_role.find(query, show)
while (yield cursor.fetch_next):
sys_user_role = cursor.next_object()
role_ids.append(sys_user_role.get("role_id", ""))
# 查询这些角色有哪些权限
node_ids = set()
query = {"role_id": {"$in": role_ids}}
show = {"_id": 0}
cursor = self.db.sys_role_node.find(query, show)
while (yield cursor.fetch_next):
sys_role_node = cursor.next_object()
node_ids.add(sys_role_node.get("node_id", ""))
if node_id in node_ids:
return 1
else:
return 0
except:
logger.error(traceback.format_exc())
return 0
def sadd(self, key, member, **kwargs):
"""
SADD key member Add the specified member to the Set value at key
param:
key:string
member:string
**kwargs:include obj and baseobj
obj:the object
baseobj: base object
return:
True or False
"""
try:
if setting.Debug:
n = datetime.datetime.now()
pipe = DSetField.redis.pipeline()
pipe.sadd(key, member)
self.change_log("set:insert", kwargs["obj"].id, kwargs["baseobj"],
pipe)
pipe.execute()
return True
except Exception, e:
pipe.reset()
logger.error(e)
return False
def lpush(self,key,value,**kwargs):
"""
LPUSH key value Append an element to the head of the List value at key
param;
key:string
value:string
**kwargs: a dict
obj:object
baseobj:base object
return:
True or False
"""
#print "listfield lpush ",key,",",value
try:
if setting.Debug:
n = datetime.datetime.now()
pipe = RedisClient.getInstance().redis.pipeline()
pipe.lpush(key,value)
self.change_log("list:insert",kwargs["obj"].id,kwargs["baseobj"],pipe)
pipe.execute()
if setting.Debug:
logger.info(" lpush key: %s,use : %s" % (key,datetime.datetime.now() - n))
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def delete(self):
"""
delete the data of object use pipe
delete index delete data of user
"""
n = datetime.now()
#注册事务
pipe = self.db.pipeline()
try:
#1.删除索引
self.drop_index(pipe)
#2.删除用户数据
pipe.delete(self.dump_key())
#3.删除用户列表中对应的用户
pipe.lrem(self.__class__.list_key(),0,self.id)
self.change_log(None,pipe,"delete")
#提交到Redis 数据库
pipe.execute()
logger.info("delete type:%s, id:%s ,use: %s" % (self.__class__.__name__,self.id,datetime.now() - n))
except Exception,e:
pipe.reset()
logger.error(str(e))
raise e
def post(self, *args, **kwargs):
res_msg = ""
prices = []
num = int(self.get_argument("num", 15))
page = int(self.get_argument("page", 1))
starting_place = self.get_argument("starting_place", "")
destination = self.get_argument("destination", "")
max_length = self.get_argument("max_length", 0)
max_width = self.get_argument("max_width", 0)
max_height = self.get_argument("max_height", 0)
weight = self.get_argument("weight", "")
is_liquid = self.get_argument("is_liquid", "")
is_electric = self.get_argument("is_electric", "")
total_count = 0
try:
if weight:
weight = float(weight)
query = {
"starting_place": starting_place,
"destination": destination,
}
show = {"_id": 0}
cursor = self.db.bijia_price.find(query, show).skip((page - 1) * num).limit(num)
while (yield cursor.fetch_next):
price = cursor.next_object()
price["total_price"] = float(price["register_price"]) + float(price["freight"]) * weight
prices.append(price)
total_count = yield self.db.bijia_price.find(query, show).count()
except:
logger.error(traceback.format_exc())
self.render("admin/bijia_list.html", prices=prices, res_msg=res_msg, total_count=total_count, page=page,
num=num)
def delete(self):
"""
delete the data of object use pipe
delete index delete data of user
"""
n = datetime.now()
#注册事务
pipe = self.db.pipeline()
try:
#1.删除索引
self.drop_index(pipe)
#2.删除用户数据
pipe.delete(self.dump_key())
#3.删除用户列表中对应的用户
pipe.lrem(self.__class__.list_key(), 0, self.id)
self.change_log(None, pipe, "delete")
#提交到Redis 数据库
pipe.execute()
logger.info("delete type:%s, id:%s ,use: %s" %
(self.__class__.__name__, self.id, datetime.now() - n))
except Exception, e:
pipe.reset()
logger.error(str(e))
raise e
def zadd(self,key ,member ,score,**kwargs):
"""
add the member into the sorted set by score
if the member is exist then update it's score
param:
key:string
member:string
score:rank integer
**kwargs:include obj and baseobj
obj:object
baseobj:base object
return:
True or False
"""
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.zadd(key ,member ,score)
self.change_log("sortset:insert",kwargs["obj"].id,kwargs["baseobj"],pipe,score)
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def rpush(self, key, value, **kwargs):
"""
push the data into list of redis at right of list
param;
key:string
value:string
**kwargs: a dict
obj:object
baseobj:base object
return:
True or False
"""
#Save
#print "listfield rpush ",key,",",value
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.rpush(key, value)
self.change_log("list:insert", kwargs["obj"].id, kwargs["baseobj"],
pipe)
pipe.execute()
return True
except Exception, e:
pipe.reset()
logger.error(e)
return False
def get(self, *args, **kwargs):
try:
line_code = self.get_argument("line_code", "")
query = {"line_code": line_code}
self.db.bijia_price.remove(query)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/price")
def get(self, *args, **kwargs):
try:
code = self.get_argument("code", "")
query = {"code": code}
self.db.bijia_country.remove(query)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/country")
def get(self, *args, **kwargs):
try:
code = self.get_argument("code", "")
query = {"code": code}
self.db.bijia_country.remove(query)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/country")
def get(self, *args, **kwargs):
try:
username = self.get_argument("username", "")
query = {"username": username}
self.db.sys_user.remove(query)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/user")
def get(self, *args, **kwargs):
try:
node_id = self.get_argument("node_id", "")
query = {"node_id": node_id}
self.db.sys_node.remove(query)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/node")
def get(self, *args, **kwargs):
try:
node_id = self.get_argument("node_id", "")
query = {"node_id": node_id}
self.db.sys_node.remove(query)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/node")
def write_error(self, status_code, **kwargs):
logger.error(traceback.format_exc())
return_data = {
"code": status_code,
"time": time.time() - self.start_time,
"results": []
}
self.write(return_data)
self.finish()
def get(self, *args, **kwargs):
res_msg = ""
country = {}
try:
abbreviate = self.get_argument("abbreviate", "")
query = {"abbreviate": abbreviate}
show = {"_id": 0}
country = yield self.db.bijia_country.find_one(query, show)
except:
logger.error(traceback.format_exc())
self.render("admin/country_add.html", res_msg=res_msg, form_action="/admin/country/add", country=country)
def get(self, *args, **kwargs):
res_msg = ""
node = {}
try:
node_id = self.get_argument("node_id", "")
query = {"node_id": node_id}
show = {"_id": 0}
node = yield self.db.sys_node.find_one(query, show)
except:
logger.error(traceback.format_exc())
self.render("admin/sys_node_add.html", node=node, res_msg=res_msg, form_action="/admin/node/update")
def get(self, *args, **kwargs):
res_msg = ""
price = {}
try:
line_code = self.get_argument("line_code", "")
query = {"line_code": line_code}
show = {"_id": 0}
price = yield self.db.bijia_price.find_one(query, show)
except:
logger.error(traceback.format_exc())
self.render("admin/price_add.html", res_msg=res_msg, form_action="/admin/price/add", price=price)
def get(self, *args, **kwargs):
res_msg = ""
user = {}
try:
username = self.get_argument("username", "")
query = {"username": username}
show = {"_id": 0}
user = yield self.db.sys_user.find_one(query, show)
except:
logger.error(traceback.format_exc())
self.render("admin/sys_user_add.html", user=user, res_msg=res_msg, form_action="/admin/user/update")
def post(self, *args, **kwargs):
role_id = self.get_argument("role_id", "")
role_name = self.get_argument("role_name", "")
try:
role_dict = {
"role_id": role_id,
"role_name": role_name,
}
query = {"role_id": role_id}
yield self.db.sys_role.update(query, role_dict, upsert=True)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/role")
def post(self, *args, **kwargs):
node_id = self.get_argument("node_id", "")
node_name = self.get_argument("node_name", "")
try:
node_dict = {
"node_id": node_id,
"node_name": node_name,
}
query = {"node_id": node_id}
yield self.db.sys_node.update(query, node_dict, upsert=True)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/node")
def post(self, *args, **kwargs):
node_id = self.get_argument("node_id", "")
node_name = self.get_argument("node_name", "")
try:
node_dict = {
"node_id": node_id,
"node_name": node_name,
}
query = {"node_id": node_id}
yield self.db.sys_node.update(query, {"$set": node_dict}, upsert=True)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/node")
def get(self, *args, **kwargs):
res_msg = ""
node = {}
try:
node_id = self.get_argument("node_id", "")
query = {"node_id": node_id}
show = {"_id": 0}
node = yield self.db.sys_node.find_one(query, show)
except:
logger.error(traceback.format_exc())
self.render("admin/sys_node_add.html",
node=node,
res_msg=res_msg,
form_action="/admin/node/update")
def post(self, *args, **kwargs):
role_id = self.get_argument("role_id", "")
role_name = self.get_argument("role_name", "")
try:
role_dict = {
"role_id": role_id,
"role_name": role_name,
}
query = {"role_id": role_id}
yield self.db.sys_role.update(query, {"$set": role_dict},
upsert=True)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/user")
def get(self, *args, **kwargs):
res_msg = ""
country = {}
try:
abbreviate = self.get_argument("abbreviate", "")
query = {"abbreviate": abbreviate}
show = {"_id": 0}
country = yield self.db.bijia_country.find_one(query, show)
except:
logger.error(traceback.format_exc())
self.render("admin/country_add.html",
res_msg=res_msg,
form_action="/admin/country/add",
country=country)
def typecast_for_storage(self, value):
"""
get the value
param:
value:string
return:
datetime
"""
if value is None:
logger.error("%s is Null" % value)
return None
if not isinstance(value, datetime.datetime):
err = "%s should be datetime object, and not a %s" % (self.name, type(value))
logger.error(err)
raise TypeError(err)
return "%s" % value.strftime("%Y-%m-%d %H:%M:%S")
def typecast_for_read(self, value):
"""
get the value
param:
value:string
return:
datetime
"""
try:
if isinstance(value,datetime.datetime):
return value
else:
return datetime.datetime.strptime(value,"%Y-%m-%d %H:%M:%S")
except TypeError, ValueError:
logger.error("%s error datetime type" % value)
return None
def zrem(self, key, member_id, **kwargs):
"""
delete the member in sorted set
param:
key:string
member_id:integer
**kwargs:dict
return:
True or False
"""
try:
DSortSetField.redis.zrem(key, member_id)
return True
except Exception, e:
logger.error(e)
return False
def zrem(self, key,member_id,**kwargs):
"""
delete the member in sorted set
param:
key:string
member_id:integer
**kwargs:dict
return:
True or False
"""
try:
DSortSetField.redis.zrem( key,member_id)
return True
except Exception,e:
logger.error(e)
return False
def _new(self, *args, **kws):
try:
obj = args[0]
#print obj.id
if hasattr(obj,"_id") or hasattr(obj,"id"):
#如果有ID只保存ID
#key = "user:id:1:posts"
key = operKey(obj,self.name) #"%s:id:%s:%s" % (obj.__class__.__name__,obj.id, self.name)
args = args[1:]
kws["obj"] = obj
return fn(self,key, *args, **kws)
else:
logger.error("please object is new not have object.id")
raise StandardError("please object is new not have object.id")
except Exception,e:
logger.error(e)
return None
def post(self, *args, **kwargs):
abbreviate = self.get_argument("abbreviate", "")
area = self.get_argument("area", "")
name_zh = self.get_argument("name_zh", "")
name_en = self.get_argument("name_en", "")
try:
country_dict = {
"abbreviate": abbreviate,
"area": area,
"name_zh": name_zh,
"name_en": name_en,
}
query = {"abbreviate": abbreviate}
yield self.db.bijia_country.update(query, {"$set": country_dict}, upsert=True)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/country")
def get(self, *args, **kwargs):
res_msg = ""
countrys = []
num = int(self.get_argument("num", 15))
page = int(self.get_argument("page", 1))
total_count = 0
try:
query = {}
show = {"_id": 0}
cursor = self.db.bijia_country.find(query, show).skip((page - 1) * num).limit(num)
while (yield cursor.fetch_next):
country = cursor.next_object()
countrys.append(country)
total_count = yield self.db.bijia_country.find().count()
except:
logger.error(traceback.format_exc())
self.render("admin/country_list.html", countrys=countrys, res_msg=res_msg, total_count=total_count, page=page, num=num)
def get_word_list(file_name):
w_list = []
f = open(file_name, "r", encoding="utf-8")
try:
all_text = f.read()
t_list = all_text.split("【")
for tex in t_list:
tex = tex.replace("\n", "")
if tex and tex.find("】"):
tem_list = tex.split("】")
if tem_list[0] and tem_list[1]:
w_list.append({"name": tem_list[0], "description": tem_list[1]})
return w_list
except:
logger.error(traceback.format_exc())
return w_list
finally:
f.close()
def zremrangebyrank(self,key,min_rank=0,max_rank=1,**kwargs):
"""
maintain the size of list
pop one object every time
param:
key:string
min_rank:integer default is 0
max_rank:integer default is 1
**kwargs:dict
retrun:
True or False
"""
try:
DSortSetField.redis.zremrangebyrank(key,min_rank,max_rank)
return True
except Exception,e:
logger.error(e)
return False
def deployVMtoMachine(self, flavor_name, image_name, nic_id, zone_name,
machine_name, instanc_name):
__novaboot = 'nova boot --flavor %s --image %s --nic net-id=%s ' \
'--security-group default --availability-zone %s:%s %s'%\
(flavor_name, image_name, nic_id, zone_name, machine_name, instanc_name)
cmd = logincmd + '&&' + __novaboot
print cmd
_, stdout, stderr = self.ssh.exec_command(logincmd + ' && ' +
__novaboot)
stderrArr = stderr.readlines()
if stderrArr == []:
for str in stdout.readlines():
logger.info(str)
return True
else:
for str in stderrArr:
logger.error(str)
return False
def post(self, *args, **kwargs):
abbreviate = self.get_argument("abbreviate", "")
area = self.get_argument("area", "")
name_zh = self.get_argument("name_zh", "")
name_en = self.get_argument("name_en", "")
try:
country_dict = {
"abbreviate": abbreviate,
"area": area,
"name_zh": name_zh,
"name_en": name_en,
}
query = {"abbreviate": abbreviate}
yield self.db.bijia_country.update(query, {"$set": country_dict},
upsert=True)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/country")
def zremrangebyrank(self, key, min_rank=0, max_rank=1, **kwargs):
"""
maintain the size of list
pop one object every time
param:
key:string
min_rank:integer default is 0
max_rank:integer default is 1
**kwargs:dict
retrun:
True or False
"""
try:
DSortSetField.redis.zremrangebyrank(key, min_rank, max_rank)
return True
except Exception, e:
logger.error(e)
return False
def post(self, *args, **kwargs):
username = self.get_argument("username", "")
password = self.get_argument("password", "")
email = self.get_argument("email", "")
tell_phone = self.get_argument("tell_phone", "")
try:
salt = hashlib.md5(username.encode('utf-8')).hexdigest()
hash_password = hashlib.sha256((password + salt).encode('utf-8')).hexdigest()
user_dict = {
"username": username,
"password": hash_password,
"email": email,
"tell_phone": tell_phone,
}
query = {"username": username}
yield self.db.sys_user.update(query, user_dict, upsert=True)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/user")
def load_cookies(self):
"""
加载cookies
:return: bool
"""
if os.path.exists(COOKIES_PATH):
try:
logger.info('加载cookies')
SESSION.cookies = self.unqueue_cookies()
self.print_title()
except EXCEPTION as e:
logger.error(f'登录失败，原因：{e}')
os.remove(COOKIES_PATH)
return False
else:
return True
else:
return False
def zrem(self, key,member_id,**kwargs):
"""
delete the member in sorted set
param:
key:string
member_id:integer
**kwargs:dict
return:
True or False
"""
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.zrem( key,member_id)
self.change_log("sortset:delete",member,kwargs["baseobj"])
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def post(self, *args, **kwargs):
line_name = self.get_argument("line_name", "")
line_code = self.get_argument("line_code", "")
company_code = self.get_argument("company_code", "")
starting_place = self.get_argument("starting_place", "")
destination = self.get_argument("destination", "")
register_price = self.get_argument("register_price", "")
freight = self.get_argument("freight", "")
arrival_time = self.get_argument("arrival_time", "")
is_electric = self.get_argument("is_electric", "")
is_liquid = self.get_argument("is_liquid", "")
arrival_rate = self.get_argument("arrival_rate", "")
max_weight = self.get_argument("max_weight", "")
condition = self.get_argument("condition", "")
special_requirement = self.get_argument("special_requirement", "")
remarks = self.get_argument("remarks", "")
statement = self.get_argument("statement", "")
try:
price_dict = {
"line_name": line_name,
"line_code": line_code,
"company_code": company_code,
"starting_place": starting_place,
"destination": destination,
"register_price": register_price,
"freight": freight,
"arrival_time": arrival_time,
"is_electric": is_electric,
"is_liquid": is_liquid,
"arrival_rate": arrival_rate,
"max_weight": max_weight,
"condition": condition,
"special_requirement": special_requirement,
"remarks": remarks,
"statement": statement,
}
query = {"line_code": line_code}
yield self.db.bijia_price.update(query, price_dict, upsert=True)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/price")
def srem(self,key,member,**kwargs):
"""
SREM key member Remove the specified member from the Set value at key
param:
key:string
member:string
**kwargs:include baseobj
baseobj: base object
return:
True or False
"""
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.srem(key,member)
self.change_log("list:delete",member,kwargs["baseobj"])
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def send_mail(message, receiver=setting.receiver):
logger.info('start sending')
sender = setting.sender
password = setting.password
smtp_server = setting.smtp_server
try:
content = '登陆验证码 %s' % message
msg = MIMEText(content, 'plain', 'utf-8')
msg['From'] = formataddr(["Server", sender])
msg['To'] = formataddr(["engineer", receiver])
msg['Subject'] = "验证码" # title
server = smtplib.SMTP(smtp_server, 25)
server.login(sender, password)
server.sendmail(sender, [
receiver,
], msg.as_string())
server.quit()
logger.info('success send')
except Exception as err:
logger.error(err)
def zadd(self, key, member, score, **kwargs):
"""
add the member into the sorted set by score
if the member is exist then update it's score
param:
key:string
member:string
score:rank integer
**kwargs:include obj and baseobj
obj:object
baseobj:base object
return:
True or False
"""
try:
if setting.Debug:
n = datetime.datetime.now()
pipe = DSortSetField.redis.pipeline()
pipe.zadd(key, member, score)
self.change_log("sortset:insert", kwargs["obj"].id,
kwargs["baseobj"], pipe, score)
pipe.execute()
#Start 删除超过LIMIT的
if self.limit > 0:
zcard = DSortSetField.redis.zcard(key)
#print "zcard",zcard
if zcard > self.limit:
#print "* " * 20
#print "Start 删除超过LIMIT的"
#print "rem %s " % key
delete_to = zcard - self.limit
DSortSetField.redis.zremrangebyrank(key, 0, delete_to)
#End
return True
except Exception, e:
pipe.reset()
logger.error(e)
return False
def lpush(self,key,value,**kwargs):
"""
push the data into list of redis at left of list
param;
key:string
value:string
**kwargs: a dict
return:
True or False
"""
#LPUSH key value Append an element to the head of the List value at key
#print "listfield lpush ",key,",",value
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.lpush(key,value)
self.change_log("list:insert",kwargs["obj"].id,kwargs["baseobj"],pipe)
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def post(self, *args, **kwargs):
name = self.get_argument("name", "")
code = self.get_argument("code", "")
address = self.get_argument("address", "")
email = self.get_argument("email", "")
tell_phone = self.get_argument("tell_phone", "")
website = self.get_argument("website", "")
try:
company_dict = {
"name": name,
"code": code,
"address": address,
"email": email,
"tell_phone": tell_phone,
"website": website,
}
query = {"code": code}
yield self.db.bijia_company.update(query, {"$set": company_dict},
upsert=True)
except:
logger.error(traceback.format_exc())
self.redirect("/admin/company")
def zadd(self,key ,member ,score,**kwargs):
"""
add the member into the sorted set by score
if the member is exist then update it's score
param:
key:string
member:string
score:rank integer
**kwargs:include obj and baseobj
obj:object
baseobj:base object
return:
True or False
"""
try:
if setting.Debug:
n = datetime.datetime.now()
pipe = DSortSetField.redis.pipeline()
pipe.zadd(key ,member ,score)
self.change_log("sortset:insert",kwargs["obj"].id,kwargs["baseobj"],pipe,score)
pipe.execute()
#Start 删除超过LIMIT的
if self.limit > 0:
zcard = DSortSetField.redis.zcard(key)
#print "zcard",zcard
if zcard > self.limit:
#print "* " * 20
#print "Start 删除超过LIMIT的"
#print "rem %s " % key
delete_to = zcard - self.limit
DSortSetField.redis.zremrangebyrank(key,0,delete_to)
#End
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def get(self, *args, **kwargs):
res_msg = ""
companys = []
num = int(self.get_argument("num", 15))
page = int(self.get_argument("page", 1))
total_count = 0
try:
query = {}
show = {"_id": 0}
cursor = self.db.bijia_company.find(query, show)
while (yield cursor.fetch_next):
company = cursor.next_object()
companys.append(company)
total_count = yield self.db.bijia_company.find().count()
except:
logger.error(traceback.format_exc())
self.render("admin/company_list.html",
companys=companys,
res_msg=res_msg,
total_count=total_count,
page=page,
num=num)
def rpush(self,key,value,**kwargs):
"""
push the data into list of redis at right of list
param;
key:string
value:string
**kwargs: a dict
return:
True or False
"""
#Save
#print "listfield rpush ",key,",",value
try:
pipe = RedisClient.getInstance().redis.pipeline()
pipe.rpush(key,value)
self.change_log("list:insert",kwargs["obj"].id,kwargs["baseobj"],pipe)
pipe.execute()
return True
except Exception,e:
pipe.reset()
logger.error(e)
return False
def post(self, *args, **kwargs):
res_msg = ""
prices = []
num = int(self.get_argument("num", 15))
page = int(self.get_argument("page", 1))
starting_place = self.get_argument("starting_place", "")
destination = self.get_argument("destination", "")
max_length = self.get_argument("max_length", 0)
max_width = self.get_argument("max_width", 0)
max_height = self.get_argument("max_height", 0)
weight = self.get_argument("weight", "")
is_liquid = self.get_argument("is_liquid", "")
is_electric = self.get_argument("is_electric", "")
total_count = 0
try:
if weight:
weight = float(weight)
query = {
"starting_place": starting_place,
"destination": destination,
}
show = {"_id": 0}
cursor = self.db.bijia_price.find(query, show).skip(
(page - 1) * num).limit(num)
while (yield cursor.fetch_next):
price = cursor.next_object()
price["total_price"] = float(
price["register_price"]) + float(price["freight"]) * weight
prices.append(price)
total_count = yield self.db.bijia_price.find(query, show).count()
except:
logger.error(traceback.format_exc())
self.render("admin/bijia_list.html",
prices=prices,
res_msg=res_msg,
total_count=total_count,
page=page,
num=num)
def get(self, *args, **kwargs):
res_msg = ""
nodes = []
num = int(self.get_argument("num", 15))
page = int(self.get_argument("page", 1))
total_count = 0
try:
query = {}
show = {"_id": 0}
cursor = self.db.sys_node.find(query, show).skip(
(page - 1) * num).limit(num)
while (yield cursor.fetch_next):
user = cursor.next_object()
nodes.append(user)
total_count = yield self.db.sys_node.find().count()
except:
logger.error(traceback.format_exc())
self.render("admin/sys_node_list.html",
nodes=nodes,
res_msg=res_msg,
total_count=total_count,
page=page,
num=num)
