def get_some(self, where={}, orderby="", offset=0, limit=0):
"""
获取满足条件的一些数据
:param where: 条件字典
:param orderby: 排序字段。如："id" 或者 "id desc"
:param offset:
:param limit:
:return:
"""
try:
with self._engine.connect() as conn:
sql = self._table.select()
if "isdel" in self._table.c.keys():
# 如果表中有isdel字段，则取isdel为False的结果
sql = self._set_where(sql, {"isdel": False})
sql = self._set_where(sql, where)
if orderby:
sql = sql.order_by(orderby)
if limit:
sql = sql.offset(offset).limit(limit)
res = conn.execute(sql).fetchall()
return res
except Exception as ex:
write_log("{}.{} raise exception,ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
return None
def image_save(content, filename=""):
try:
if not content:
# 待写入的内容为空
write_log("imagemanage.image_save()，待写入的内容为空")
return
# 申明使用全局变量
global project_dir
# 路径处理
file_path = "{}/static/images".format(project_dir)
if not os.path.exists(file_path):
os.makedirs(file_path)
if not filename:
full_name = "{}/verifyimage.png".format(file_path)
else:
full_name = "{}/{}".format(file_path, filename)
if isinstance(content, bytes):
f = open(full_name, "wb")
elif isinstance(content, str):
f = open(full_name, "w")
f.write(content)
f.close()
except Exception as ex:
write_log("imagemanage.image_save() raise Exception, ex=".format(
repr(ex)))
def get_some8ids_specific_fields(self,
fields,
ids,
ids_row="id",
orderby="",
offset=0,
limit=0):
"""
根据id列表获取一些数据（指定字段）
:param fields:
:param ids: id列表
:param orderby: 排序字段。如："id" 或者 "id desc"
:param offset:
:param limit:
:return:
"""
if not fields or not ids:
return None
try:
with self._engine.connect() as conn:
sql = select([getattr(self._table.c, rn) for rn in fields
]).where(self._table.c.id.in_(ids))
if orderby:
sql = sql.order_by(orderby)
if limit:
sql = sql.offset(offset).limit(limit)
res = conn.execute(sql).fetchall()
return res
except Exception as ex:
write_log("{}.{} raise exception,ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
return None
def delete(self, where, real_del=True):
"""
删除，默认真删除
:param where: 条件字典
:param real_del: 是否真删除，默认为True
:return:
"""
try:
with self._engine.connect() as conn:
if real_del:
# 真删除
sql = self._table.delete()
sql = self._set_where(sql, where)
return conn.execute(sql)
else:
# 软删除
if "isdel" in self._table.c.keys():
sql = self._table.update()
sql = self._set_where(sql, where)
sql = sql.values({"isdel": True})
return conn.execute(sql)
else:
# 表中没有标记删除的字段
write_log(
"function {}.{}, table has no “isdel” field!".
format(
self.__class__.__name__,
sys._getframe().f_code.co_name,
))
return None
except Exception as ex:
write_log("{}.{} raise exception,ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
return None
def get_some8ids(self, ids, ids_row="id", orderby="", offset=0, limit=0):
"""
根据id列表获取一些数据
:param ids: id列表
:param orderby: 排序字段。如："id" 或者 "id desc"
:param offset:
:param limit:
:return:
"""
if not ids:
return None
try:
with self._engine.connect() as conn:
sql = self._table.select().where(
getattr(self._table.c, ids_row).in_(ids))
if "isdel" in self._table.c.keys():
sql = sql.where(self._table.c.isdel == False)
if orderby:
sql = sql.order_by(orderby)
if limit:
sql = sql.offset(offset).limit(limit)
res = conn.execute(sql).fetchall()
return res
except Exception as ex:
write_log("{}.{} raise exception,ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
return None
def post(self, *args, **kwargs):
try:
role_model = Role()
power_ids = self.get_args("power_ids")
role_id = self.get_args("role_id")
if is_empty(role_id):
self.send_fail_json(reason="role_id不能为空")
return
# 更新角色权限
up_res = role_model.update(where={"id": role_id},
data={"power_ids": power_ids})
if not up_res:
# 更新失败
self.send_fail_json(reason="更新失败")
return
write_log("'{}'修改了角色(ID为：{})权限".format(self.user["id"], role_id),
LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def get_some_generator(self, where={}, orderby="", offset=0, limit=100):
try:
num_all = 0
while 1:
with self._engine.connect() as conn:
sql = self._table.select().prefix_with(
"SQL_CALC_FOUND_ROWS")
if "isdel" in self._table.c.keys():
# 如果表中有isdel字段，则取isdel为False的结果
sql = self._set_where(sql, {"isdel": False})
sql = self._set_where(sql, where)
if orderby:
sql = sql.order_by(orderby)
sql = sql.offset(offset).limit(limit)
res = conn.execute(sql).fetchall()
if not num_all:
num_all = conn.execute("select FOUND_ROWS();").scalar()
offset += limit
yield res
if offset > num_all:
return None
except Exception as ex:
write_log("{}.{} raise exception,ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
return None
def is_proxy_valid(self, proxies):
"""
判断该代理host是否可用
:param proxies: 代理，如：http://123.12.43.35:3280
:return:
"""
# http类型的代理
try:
test_url = "http://pv.sohu.com/cityjson?ie=utf-8"
response = requests.get(
test_url,
proxies={self.proxy_type: proxies},
headers={"User-Agent": random.choice(settings.USER_AGENTS)},
timeout=3,
)
if response.text.find("returnCitySN") == -1:
# 代理没用
write_log("request is right,but response is not true")
return False
else:
return True
except Exception as e:
write_log("raise exception in is_proxy_valid(),message={}".format(
repr(e)))
return False
def post(self, *args, **kwargs):
"""
执行修改微博产品
:param args:
:param kwargs:
:return:
"""
try:
product_id = self.get_args("product_id", "")
if is_empty(product_id):
self.send_fail_json("产品id不能为空")
return
# 产品名
name = self.get_args("name")
if is_empty(name):
# 产品名不能为空
self.send_fail_json("产品名不能为空")
return
# 产品类型
types = self.get_args("types")
if is_empty(types):
# 产品名不能为空
self.send_fail_json("类型不能为空")
return
# 产品单价
price = self.get_args("price")
if is_empty(price):
# 产品单价不能为空
self.send_fail_json("单价不能为空")
return
data = dict(
types=types,
price=price,
update_time=datetime.now(),
)
# 备注
comments = self.get_args("comments")
if comments:
data["comments"] = comments
res = Product().update(where={"id": product_id}, data=data)
if not res:
self.send_fail_json("修改失败")
return
write_log("'{}'修改了一个微博产品(ID为：{})".format(self.user["id"], product_id), LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name,
repr(ex)
))
self.send_fail_json("系统错误，稍会儿再试")
def get_one8namepwd(self, username="", pwd=""):
if not username or not pwd:
write_log("sys_user.SysUser.get_one(), username or pwd is empty")
return None
where = dict()
where["enable"] = True
where["name"] = username
where["pwd"] = pwd
return super().get_one(where)
def post(self, *args, **kwargs):
try:
if not self.user:
# 缓存为空，跳转到登录页
self.redirect("/login/")
return
user = SysUser().get_one8id(self.user["id"])
# todo 收款成功，则修改用户余额
# pass
charge_num = self.get_args("charge_num")
if is_empty(charge_num):
self.send_fail_json("充值金额不能为空")
return
user_balance = Decimal(user.balance) + Decimal(charge_num)
with db_engine.connect() as conn:
tran = conn.begin()
try:
# 更新用户数据表
res = SysUser().update({"id": user.id},
{"balance": user_balance})
if not res:
tran.rollback()
self.send_fail_json("充值失败")
return
# 掺入用户充值记录
res = SysUserChargeLog().add({
"user_id": user.id,
"amount": charge_num,
"comments": "用户充值",
"create_time": datetime.now(),
})
if not res:
tran.rollback()
self.send_fail_json("充值失败")
return
# 提交事务
tran.commit()
except Exception as ex:
tran.rollback()
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("充值失败，稍会儿再试")
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def post(self, *args, **kwargs):
"""
执行添加微博产品
:param args:
:param kwargs:
:return:
"""
try:
# 产品类型
types = self.get_args("types")
if is_empty(types):
# 产品类型不能为空
self.send_fail_json("产品类型不能为空")
return
# 产品名
product_name = self.get_args("name")
if is_empty(product_name):
# 产品名不能为空
self.send_fail_json("产品名不能为空")
return
# 产品单价
price = self.get_args("price")
if is_empty(price):
# 产品单价不能为空
self.send_fail_json("单价不能为空")
return
data = dict(
source=PRODUCT_SOURCE["weibo"],
types=types,
name=product_name,
price=price,
create_time=datetime.now(),
)
# 备注
comments = self.get_args("comments")
if comments:
data["comments"] = comments
res = Product().add(data=data)
if not res:
self.send_fail_json("添加失败")
return
write_log("'{}'添加了一个微博产品(product_name为：{})".format(self.user["id"], product_name), LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name,
repr(ex)
))
self.send_fail_json("系统错误，稍会儿再试")
def post(self, *args, **kwargs):
"""
执行添加菜单
:param args:
:param kwargs:
:return:
"""
try:
# 权限
power_id = self.get_args("power_id")
if is_empty(power_id):
# 权限不能为空
self.send_fail_json("权限不能为空")
return
# 菜单名
menu_name = self.get_args("menu_name", "")
if is_empty(menu_name):
# 菜单名不能为空
self.send_fail_json("菜单名不能为空")
return
# url
url = self.get_args("url", default=None, data_type=None)
# 父级id
fid = self.get_args("fid", default=0, data_type=int)
# 排序
sort = self.get_args("sort", default=0, data_type=int)
data = dict(
url=url,
power_id=power_id,
name=menu_name,
create_time=datetime.now(),
fid=fid,
sort=sort,
)
# 图标
icon = self.get_args("icon", "")
if icon:
data["icon"] = icon
res = Menu().add(data=data)
if not res:
self.send_fail_json("添加失败")
return
write_log("'{}'添加了一个菜单(名称为：{})".format(self.user["id"], menu_name),
LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def update_login_ip(self, user_id, login_ip):
if not user_id or not login_ip:
write_log(
"sys_user.SysUser.update_login_ip(), user_id or login_ip is empty"
)
return None
where = dict()
where["id"] = user_id
data = dict(login_ip=login_ip)
return super().update(where, data)
def post(self):
try:
self.clear_cookie("token")
write_log("'{}'用户注销成功了".format(self.user["id"]), LOG_TYPE_OPERATE)
self.send_ok_json()
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def post(self):
try:
# 登录操作
user_model = SysUser()
username = self.get_argument("username", "")
pwd = self.get_argument("password", "")
captcha = self.get_argument("captcha", "")
if not username or not pwd or not captcha:
self.send_fail_json("请输入合法的账号或者密码或者验证码")
return
if not self.check_captcha(captcha):
# 验证码不正确
self.send_fail_json("验证码不正确")
return
user = user_model.get_one8namepwd(username=username,
pwd=self.md5_password(pwd))
if not user:
self.send_fail_json("请确保用户名和密码正确")
return
# 删除同一个用户的所有登录缓存
cache = self.cache
cache.delete_cache(self.token_key.format(tk="*", uid=user.id))
# token加密
token = hashlib.md5("{}{}{}".format(
user.id, settings.PLATFORM_USER_TOKEN_SECRET,
int(time.time())).encode("utf-8")).hexdigest()
# 获取当前登录用户的token_key
token_key = self.token_key.format(tk=token, uid=user.id)
# 重新设置该登录用户的缓存
cache.set_cache(
token_key,
dict(id=user.id,
name=user.name,
role_id=user.role_id,
fid=user.fid), 3600)
# 更新用户最后一次登录ip
user_model.update_login_ip(user.id, self.request.remote_ip)
# self.ip_limit(target_ip=self.request.remote_ip)
self.set_secure_cookie(name="token", value=token, expires_days=1)
write_log(
"'{}'用户登录成功了，登录IP为：{}".format(user.id, self.request.remote_ip),
LOG_TYPE_OPERATE)
self.send_ok_json()
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def post(self, *args, **kwargs):
"""
执行登录
:param args:
:param kwargs:
:return:
"""
try:
weibouser_model = WeiboUser()
account_id = self.get_args("id", "")
if not account_id:
self.send_fail_json("account_id不能为空")
return
# 获取验证码
verifycode = self.get_args("verifycode", "")
# 执行登录
user = WeiboUser().get_one_specific_fields8id(("id", "username", "pwd", "cookies"), account_id)
res = Weibo(init_session=False).do_login(user, verifycode)
# res = do_login(verifycode)
if not res.get("status"):
# 登录失败，账号或者密码错误，或者需要验证码
self.send_fail_json(res.get("reason"), data={"needverify": res.get("needverify")})
return
# 登录成功
data = dict(islogin=True, last_login_time=datetime.now())
# cookies 入库
cookies = res.get("cookies", "")
if cookies:
data.update(cookies=myjson.dumps(cookies))
uniqueid = res.get("uniqueid", "")
if uniqueid:
data.update(uniqueid=uniqueid)
userdomain = res.get("userdomain", "")
if userdomain:
data.update(userdomain=userdomain)
weibouser_model.update({"id": account_id}, data)
write_log("'{}'成功登录了微博(微博ID为：{})".format(self.user["id"], account_id), LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name,
repr(ex)
))
self.send_fail_json("系统错误，稍会儿再试")
def post(self, *args, **kwargs):
try:
cache_user = self.user
password1 = self.get_args("password1")
if not password1:
self.send_fail_json("旧密码不能为空")
return
password2 = self.get_args("password2")
if not password2:
self.send_fail_json("新密码不能为空")
return
password3 = self.get_args("password3")
if not password3:
self.send_fail_json("重复密码不能为空")
return
if password2 != password3:
self.send_fail_json("新密码必须一致")
return
if not is_pwd(password2):
self.send_fail_json("密码格式不正确")
return
user_model = SysUser()
res = user_model.get_one8namepwd(username=cache_user["name"],
pwd=self.md5_password(password1))
if not res:
self.send_fail_json("旧密码错误")
return
# 更新数据库
pwd = self.md5_password(password2)
data = dict(pwd=pwd)
update_res = user_model.update({"id": cache_user.get("id", "")},
data)
if not update_res:
self.send_fail_json("修改密码失败")
return
# 更新缓存
self.update_user_cache({"pwd": pwd})
write_log(
"'{}'修改了登录密码，修改后的密码为：{}".format(self.user["id"], password2),
LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def post(self, *args, **kwargs):
"""
执行修改微博账号
:param args:
:param kwargs:
:return:
"""
try:
account_id = self.get_args("account_id", "")
if is_empty(account_id):
self.send_fail_json("账号id不能为空")
return
# 用户名
username = self.get_args("username")
if is_empty(username):
# 用户名不能为空
self.send_fail_json("用户名不能为空")
return
# 登录密码
pwd = self.get_args("pwd", "")
if is_empty(pwd):
# 密码不能为空
self.send_fail_json("密码不能为空")
return
pwd = aes_encrypt(pwd)
data = dict(
username=username,
pwd=pwd,
update_time=datetime.now(),
)
# 备注
comments = self.get_args("comments")
if comments:
data["comments"] = comments
res = WeiboUser().update(where={"id": account_id}, data=data)
if not res:
self.send_fail_json("修改失败")
return
write_log("'{}'修改了一个微博账号(ID为：{})".format(self.user["id"], account_id), LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name,
repr(ex)
))
self.send_fail_json("系统错误，稍会儿再试")
def get_one8id(self, id):
"""
根据id获取某条数据
:param id:
:return:
"""
if not id:
write_log("function {}.get_one8id() no id")
return None
where = dict()
where["id"] = id
return self.get_one(where)
def post(self, *args, **kwargs):
try:
data = dict()
real_name = self.get_args("real_name")
if real_name:
data.update(real_name=real_name)
tel = self.get_args("tel")
if tel:
data.update(tel=tel)
email = self.get_args("email")
if email:
data.update(email=email)
gender = self.get_args("gender")
if gender:
data.update(gender=gender)
birthday = self.get_args("birthday")
if birthday:
data.update(birthday=birthday)
comments = self.get_args("comments")
if comments:
data.update(comments=comments)
cache_user = self.user
if not cache_user:
# 缓存为空，跳转到登录页
self.redirect("/login/")
return
# 更新用户数据表
res = SysUser().update({"id": cache_user.get("id", "")}, data)
if not res:
self.send_fail_json("修改失败")
return
# 更新用户缓存
self.update_user_cache(data)
write_log("'{}'修改了个人信息".format(self.user["id"]), LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def post(self, *args, **kwargs):
"""
执行充值
:param args:
:param kwargs:
:return:
"""
try:
user_id = self.get_args("user_id", "")
if is_empty(user_id):
self.send_fail_json("用户id不能为空")
return
# 充值数量
charge_num = self.get_args("charge_num")
if is_empty(charge_num):
# 充值数量不能为空
self.send_fail_json("充值数量不能为空")
return
charge_num = Decimal(charge_num)
# 查询支付账户余额是否满足此次充值
payment_account = SysUser().get_one8id(settings.PaymentAccount)
if payment_account.balance - charge_num < 0:
# 支付账户余额不足
self.send_fail_json("支付账户余额不足")
return
# 用户充值
res = db_engine.transaction(dbengine_transaction,
func=user_charge,
user_id=user_id,
charge_num=charge_num)
if not res:
self.send_fail_json("充值失败")
return
write_log(
"'{}'给用户(ID为：{})充值了{} {}".format(
self.user["id"],
user_id,
charge_num,
settings.COIN_NAME,
), LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def add(self, data):
"""
添加
:param data:待添加的数据字典
:return:
"""
try:
with self._engine.connect() as conn:
sql = self._table.insert().values(data)
return conn.execute(sql)
except Exception as ex:
write_log("{}.{} raise exception,ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
return None
def post(self, *args, **kwargs):
"""
执行权限修改
:param args:
:param kwargs:
:return:
"""
try:
power_id = self.get_args("id")
if is_empty(power_id):
# power_id不能为空
self.send_fail_json("id不能为空")
return
mark = self.get_args("mark")
if is_empty(mark):
# 标识不能为空
self.send_fail_json("标识不能为空")
return
name = self.get_args("name")
if is_empty(name):
# 名称不能为空
self.send_fail_json("名称不能为空")
return
data = dict(
mark=mark.upper(),
name=name,
update_time=datetime.now(),
)
comments = self.get_args("comments")
if comments:
data["comments"] = comments
res = Power().update(where={"id": power_id}, data=data)
if not res:
self.send_fail_json("更新失败")
return
write_log("'{}'修改了一个权限(ID为：{})".format(self.user["id"], power_id),
LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def post(self, *args, **kwargs):
"""
执行修改角色
:param args:
:param kwargs:
:return:
"""
try:
role_id = self.get_args("role_id")
if is_empty(role_id):
# role_id不能为空不能为空
self.send_fail_json("role_id不能为空")
return
name = self.get_args("name")
if is_empty(name):
# 角色名称不能为空
self.send_fail_json("角色名称不能为空")
return
types = self.get_args("types")
if is_empty(types):
# 角色类型不能为空
self.send_fail_json("角色类型不能为空")
return
data = dict(
name=name,
types=types,
update_time=datetime.now(),
)
comments = self.get_args("comments")
if comments:
data["comments"] = comments
res = Role().update(where={"id": role_id}, data=data)
if not res:
self.send_fail_json("更新失败")
return
write_log("'{}'修改了一个角色，角色名称为：{}".format(self.user["id"], name),
LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def update(self, where, data):
"""
更新
:param where:更新时的条件字典
:param data: 待更新的数据字典
:return:
"""
try:
with self._engine.connect() as conn:
sql = self._table.update()
sql = self._set_where(sql, where)
sql = sql.values(data)
return conn.execute(sql)
except Exception as ex:
write_log("{}.{} raise exception,ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
return None
def get(self, *args, **kwargs):
try:
role_id = self.get_args("id", "")
if not role_id:
self.send_fail_json("id不能为空")
res = Role().delete(where={"id": role_id})
if not res:
self.send_fail_json("删除失败")
return
write_log("'{}'删除了角色(ID为：{})".format(self.user["id"], role_id),
LOG_TYPE_OPERATE)
self.send_ok_json("")
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
self.send_fail_json("系统错误，稍会儿再试")
def get_one_specific_fields8id(self, fields, id=0):
"""
根据id获取某条数据（指定字段）
:param fields: 待查找的字段列表
:param id:
:return:
"""
try:
if not fields or not id:
None
with self._engine.connect() as conn:
sql = select([getattr(self._table.c, rn) for rn in fields
]).where(self._table.c.id == id).limit(1)
res = conn.execute(sql).fetchone()
return res
except Exception as ex:
write_log("{}.{} raise exception,ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
return None
def get_all(self, orderby=""):
"""
获取所有
:param orderby: 排序字段。如："id" 或者 "id desc"
:return:
"""
try:
with self._engine.connect() as conn:
sql = self._table.select()
if "isdel" in self._table.c.keys():
# 如果表中有isdel字段，则取isdel为False的结果
sql = self._set_where(sql, {"isdel": False})
if orderby:
sql = sql.order_by(orderby)
res = conn.execute(sql).fetchall()
return res
except Exception as ex:
write_log("{}.{} raise exception,ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name, repr(ex)))
return None
def get(self, *args, **kwargs):
try:
account_id = self.get_args("id", "")
if not account_id:
self.send_fail_json("account_id不能为空")
return
user = WeiboUser().get_one_specific_fields8id(("id", "username", "pwd", "cookies"), account_id)
res = Weibo().load_login_page(user)
if res["islogin"]:
# 已登录
self.send_ok_json("")
else:
# 未登录
self.send_fail_json(data={"needverify": res["needverify"]})
except Exception as ex:
write_log("{}.{} raise exception, ex={}".format(
self.__class__.__name__,
sys._getframe().f_code.co_name,
repr(ex)
))
self.send_fail_json("系统错误，稍会儿再试")
