def update_permission(self):
args = request.args.to_dict()
log.info("args", args)
data = json.loads(request.data)
log.info("data", data)
if "token" not in args:
return PARAMS_MISS
maid = token_to_usid(args.get("token"))
manager = self.smanager.get_manager_by_maid(maid)
if manager.MAidentity != 100:
return get_response("ERROR_MESSAGE_NO_PERMISSION", "MANAGERSYSTEMERROR", "ERROR_CODE_NO_PERMISSION")
if "PEid" not in data:
return PARAMS_MISS
permission = {
"PEtype": data.get("PEtype"),
"PEsubLevel": data.get("PEsubLevel"),
}
try:
update_result = self.sapproval.update_permission(data.get("PEid"), permission)
if not update_result:
return get_response("ERROR_MESSAGE_DB_ERROR", "MANAGERSYSTEMERROR", "ERROR_CODE_DB_ERROR")
return get_response("SUCCESS_MESSAGE_UPDATE_DATA", "OK")
except Exception as e:
log.error("update permission", e.message)
return SYSTEM_ERROR
def update_manager_by_matel(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
data = json.loads(request.data)
log.info("data", data)
if "MAtelphone" not in data:
return PARAMS_MISS
maid = token_to_usid(args.get("token"))
manager = self.smanager.get_manager_by_maid(maid)
if manager.MAidentity > 101:
return get_response("ERROR_MESSAGE_NO_PERMISSION",
"MANAGERSYSTEMERROR",
"ERROR_CODE_NO_PERMISSION")
try:
from ManagerSystem.models.model import Manager
mng = {
"MAstatus":
conversion_MAstatus_resverse.get(get_str(data, "MAstatus"))
}
update_result = self.smanager.update_users_by_matel(
data.get("MAtelphone"), mng)
if not update_result:
return get_response("ERROR_MESSAGE_DB_ERROR",
"MANAGERSYSTEMERROR",
"ERROR_CODE_DB_ERROR")
return get_response("SUCCESS_MESSAGE_UPDATE_DATA", "OK")
except Exception as e:
log.error("update users", e.message)
return SYSTEM_ERROR
def update_order_main(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
maid = token_to_usid(args.get("token"))
if not maid:
return TOKEN_ERROR
data = json.loads(request.data)
log.info("data", data)
if "OMstatus" not in data or "OMid" not in data:
return PARAMS_MISS
try:
omstatus = cvs.conversion_OMstatus_reverse.get(
get_str(data, "OMstatus"))
update_result = self.sorder.update_order(get_str(data, "OMid"),
{"OMstatus": omstatus})
log.info("update_result", update_result)
if not update_result:
return get_response("ERROR_MESSAGE_DB_ERROR",
"MANAGERSYSTEMERROR",
"ERROR_CODE_DB_ERROR")
return get_response("SUCCESS_MESSAGE_UPDATE_ORDER", "OK")
except Exception as e:
log.error("update order", e.message)
return SYSTEM_ERROR
def add_approval(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
data = json.loads(request.data)
log.info("data", data)
if "PEtype" not in data or "APcontent" not in data:
return PARAMS_MISS
petype = conversion_PEtype_resverse.get(get_str(data, "PEtype"))
apreceive_list =[apreceive.MAid for apreceive in self.sapproval.get_permission_by_petype_pesublevel(petype, 1)]
if not apreceive_list:
return get_response("ERROR_MESSAGE_DB_ERROR", "MANAGERSYSTEMERROR", "ERROR_CODE_DB_ERROR")
apstart = token_to_usid(args.get("token"))
try:
apname = get_str(data, "PEtype") + str(uuid.uuid1())
for apreceive in apreceive_list:
self.sapproval.add_model("Approval", **{
"APid": str(uuid.uuid1()),
"APname": apname,
"APstart": apstart,
"APstatus": 445,
"APreceive": apreceive,
"PEtype": petype,
"APremark": "",
"APcontent": data.get("APcontent"),
"APtime": TimeManager.get_db_time_str()
})
return get_response("SUCCESS_MESSAGE_ADD_DATA", "OK")
except Exception as e:
log.error("add approval", e.message)
return SYSTEM_ERROR
def update_stock_product(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
data = json.loads(request.data)
log.info("data", data)
if "SPid" not in data:
return PARAMS_MISS
spid = data.get("SPid")
sp = {}
for key in self.stock_product_key_list:
if key not in data:
return PARAMS_MISS
sp[key] = data.get(key)
try:
log.info("sp", sp)
update_result = self.sstocks.update_stock_product(spid, sp)
log.info("update result", update_result)
if not update_result:
return get_response("ERROR_MESSAGE_DB_ERROR",
"MANAGERSYSTEMERROR",
"ERROR_CODE_DB_ERROR")
return get_response("SUCCESS_MESSAGE_UPDATE_DATA", "OK")
except Exception as e:
log.error("add stock product error", e.message)
return SYSTEM_ERROR
def get_stock(self):
args = request.args.to_dict()
log.info("args", args)
params_list = ["token", "STid"]
for key in params_list:
if key not in args:
return PARAMS_MISS
maid = token_to_usid(args.get("token"))
prid_list = [
product.PRid for product in self.sproduct.get_product_by_maid(maid)
]
pbid_list = []
for prid in prid_list:
pbid_list.extend([
productbrand.PBid for productbrand in
self.sproduct.get_productbrand_by_prid(prid)
])
stocks_list = []
for pbid in pbid_list:
stocks_list.extend(tolist(self.sstocks.get_stocks_by_PBid(pbid)))
if args.get("STid") not in stocks_list:
return get_response("ERROR_MESSAGE_DB_ERROR", "MANAGERSYSTEMERROR",
"ERROR_CODE_DB_ERROR")
stock = todict(self.sstocks.get_stock_by_stid(args.get("STid")))
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = stock
return response
def get_users(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
maid = token_to_usid(args.get("token"))
try:
manager = self.smanager.get_manager_by_maid(maid)
if not manager:
return SYSTEM_ERROR
if manager.MAidentity > 101:
return get_response("ERROR_MESSAGE_NO_PERMISSION",
"MANAGERSYSTEMERROR",
"ERROR_CODE_NO_PERMISSION")
page_size = int(args.get("page_size"))
page_num = int(args.get("page_num"))
or_filter = set()
if args.get("USfilter"):
from ManagerSystem.models.model import Users
or_filter.add(
Users.USname.like("%{0}%".format(get_str(args,
"USfilter"))))
or_filter.add(
Users.UStelphone.like("%{0}%".format(
get_str(args, "USfilter"))))
from ManagerSystem.config.conversion import conversion_USsex
pn, count = self.check_page_value(page_num,
page_size, "model.Users.USid",
set(), or_filter)
start_num = (pn - 1) * page_size
users = tolist(
self.smanager.get_users(start_num, page_size, or_filter))
for user in users:
user["USsex"] = conversion_USsex.get(user.get("USsex"))
user["UScreateTime"] = TimeManager.get_web_time_str(
user.get("UScreateTime"))
user["USloginTime"] = TimeManager.get_web_time_str(
user.get("USloginTime"))
user["USstatus"] = conversion_MAstatus.get(
user.get("USstatus"))
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = {
"count": count,
"page_num": pn,
"page_size": page_size,
"USers": users
}
return response
except Exception as e:
log.error("get users", e.message)
return SYSTEM_ERROR
def update_manager(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
data = json.loads(request.data)
log.info("data", data)
if "MAidentity" not in data or "MAstatus" not in data:
return PARAMS_MISS
manager = {"MAcreatTime": TimeManager.get_db_time_str()}
if data.get("MAidentity"):
manager["MAidentity"] = conversion_MAidentity_reverse.get(
data.get("MAidentity", "卖家"))
if data.get("MAstatus"):
manager["MAstatus"] = conversion_MAstatus_resverse.get(
data.get("MAstatus"), "可用")
maid = token_to_usid(args.get("token"))
try:
self.smanager.update_manager(maid, manager)
return get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
except Exception as e:
log.error("UPDATEERROR", e.message)
return SYSTEM_ERROR
def get_child(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
ctid = get_str(args, "CTid", "0")
if not ctid:
ctid = "0"
try:
category_filter = {Category.CTfromid == ctid}
if "category_filter" in args:
category_filter.add(
Category.CTname.like("%{0}%".format(
get_str(args, "category_filter"))))
ct_list = tolist(
self.scategory.get_category_by_and_filter(category_filter))
log.info("ct_list", ct_list)
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = ct_list
return response
except Exception as e:
log.error("get child", e.message)
return SYSTEM_ERROR
def get_category_by_prname(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args or "PRname" not in args:
return PARAMS_MISS
prname = get_str(args, "PRname")
from ManagerSystem.models.model import Products
pr_filter = {Products.PRname.like("%{0}%".format(prname))}
from ManagerSystem.service.SProducts import SProducts
spro = SProducts()
pr_list = tolist(spro.get_product_by_filter(pr_filter))
pr_list = pr_list[:find_category_by_prname_size]
log.info("pr list", pr_list)
ctname_list = []
for pr in pr_list:
ct_filter = {Category.CTid == pr.get("CTid")}
ct_name = tolist(
self.scategory.get_category_by_or_filter(ct_filter))
if not ct_name:
continue
ct_name = ct_name[0]
log.info("ct name", ct_name)
if ct_name in ctname_list:
continue
ctname_list.append(ct_name)
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = ctname_list[:find_category_by_prname_size]
return response
def get_omfilter(self):
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = [
{
"name": "订单号",
"value": "",
"key": "OMid"
},
{
"name": "订单状态",
"value": cvs.conversion_OMstatus_reverse.keys(),
"key": "OMstatus"
},
{
"name": "下单时间",
"value": "",
"key": "OMstartTime"
},
{
"name": "下单时间",
"value": "",
"key": "OMendTime"
},
{
"name": "物流方式",
"value": ["顺丰速运"],
"key": "OMlogisticsName"
},
{
"name": "商品名称",
"value": "",
"key": "PRname"
},
]
return response
def update_pro_info(self):
args = request.args.to_dict()
log.info("args", args)
data = json.loads(request.data, encoding="utf8")
log.info("data", data)
if "token" not in args:
return PARAMS_MISS
if "PRid" not in data:
return PARAMS_MISS
prid = data.get("PRid")
product = {
"PRimage": json.dumps(data.get("PRimage", [])),
"PRvideo": data.get("PRvideo", ""),
"PRfranking": data.get("PRfranking", 0),
"PRPoint": data.get("PRPoint", ""),
"PRtime": TimeManager.get_db_time_str(),
}
if data.get("PRbrand"):
product["PRbrand"] = json.dumps(data.get("PRbrand"))
try:
update_result = self.sproduct.update_product(prid, product)
log.info("update result", update_result)
if not update_result:
return get_response("ERROR_MESSAGE_DB_ERROR", "MANAGERSYSTEMERROR", "ERROR_CODE_DB_ERROR")
# brid_list = [br.BRid for br in self.sproduct.get_brid_by_prid(prid)]
# while True:
# fromid_list = []
# if not brid_list:
# break
# for brid in brid_list:
# fromid = self.sproduct.get_brfromid_by_brid(brid)
# if fromid != "0":
# fromid_list.append(fromid)
# self.sproduct.del_brand(brid)
# brid_list = {}.fromkeys(fromid_list).keys()
delete_result = self.sproduct.delete_pb(prid)
log.info("delete result", delete_result)
self.add_brands(prid, data.get("brands"), data.get("brands_key"))
return get_response("SUCCESS_MESSAGE_UPDATE_DATA", "OK")
except Exception as e:
log.error("update product", e.message)
return SYSTEM_ERROR
def forget_password(self):
data = json.loads(request.data)
log.info("data", data)
params_key_list = [
"MApasswordnew", "MApasswordnewrepeat", "MAtelphone", "MAcode"
]
for key in params_key_list:
if key not in data:
return PARAMS_MISS
Utel = data["MAtelphone"]
try:
manager = self.smanager.get_manager_by_matelphone(Utel)
log.info("manager", manager)
if not manager:
return get_response("ERROR_MESSAGE_NONE_TELPHONE",
"MANAGERSYSTEMERROR",
"ERROR_CODE_NONE_TELPHONE")
code_in_db = self.smanager.get_code_by_utel(Utel)
if not code_in_db:
return get_response("ERROR_MESSAGE_WRONG_TELCODE",
"MANAGERSYSTEMERROR",
"ERROR_CODE_WRONG_TELCODE")
if code_in_db.ICcode != data["MAcode"]:
return get_response("ERROR_MESSAGE_WRONG_TELCODE",
"MANAGERSYSTEMERROR",
"ERROR_CODE_WRONG_TELCODE")
if data["MApasswordnew"] != data["MApasswordnewrepeat"]:
return get_response("ERROR_MESSAGE_WRONG_REPEAT_PASSWORD",
"MANAGERSYSTEMERROR",
"ERROR_CODE_WRONG_REPEAT_PASSWORD")
users = {}
Upwd = data["MApasswordnew"]
users["MApassword"] = Upwd
update_info = self.smanager.update_users_by_matel(Utel, users)
log.info("update info", update_info)
if not update_info:
return SYSTEM_ERROR
return get_response("SUCCESS_MESSAGE_UPDATE_PASSWORD", "OK")
except Exception as e:
log.error("forget pwd error", e.message)
return SYSTEM_ERROR
def add_manager(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
smid = token_to_usid(args.get("token"))
smanager = self.smanager.get_manager_by_maid(smid)
if smanager.MAidentity != 100:
return get_response("ERROR_MESSAGE_NO_PERMISSION",
"MANAGERSYSTEMERROR",
"ERROR_CODE_NO_PERMISSION")
data = json.loads(request.data)
log.info("data", data)
manager_key = ["MAtelphone", "MAemail", "MAname"]
manager = {}
for key in manager_key:
if key in data:
manager[key] = data.get(key)
maid = str(uuid.uuid1())
manager["MAid"] = maid
manager["MAname"] = get_str(data, "MAname")
manager["MAtelphone"] = get_str(data, "MAtelphone")
manager["MApassword"] = self.create_password()
manager["MAemail"] = get_str(data, "MAemail")
manager["MAidentity"] = 101
manager["MAstatus"] = 153
manager["MAstatus"] = 153
manager["MAcreatTime"] = TimeManager.get_db_time_str()
manager["MAendTime"] = TimeManager.get_forward_time(days=365)
manager["MAloginTime"] = TimeManager.get_db_time_str()
self.smanager.add_model("Manager", **manager)
from ManagerSystem.service.SInterface import SInterface
from ManagerSystem.models.model import Menu
sinterface = SInterface()
mmlist = sinterface.get_menu_by_filter({Menu.MNparent != "0"})
for mm in mmlist:
self.smanager.add_model("ManagerMenu",
MMid=str(uuid.uuid1()),
MAid=maid,
MNid=mm.MNid)
response = get_response("SUCCESS_MESSAGE_REGISTER", "OK")
response["data"] = manager
return response
def get_acabo(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args or "COid" not in args:
return PARAMS_MISS
try:
maid = token_to_usid(args.get("token"))
except:
return TOKEN_ERROR
manager = self.smanager.get_manager_by_maid(maid)
if not manager:
return TOKEN_ERROR
coid = args.get("COid")
try:
co = tolist(
self.sactive.get_actives_by_filter(
{CouponsActives.COid == coid}, set()))
log.info("co", co)
if not co:
return get_response("ERROR_MESSAGE_DB_ERROR",
"MANAGERSYSTEMERROR",
"ERROR_CODE_DB_ERROR")
co = co[0]
co["COstatus"] = conversion_COstatus.get(co["COstatus"])
co["COtype"] = conversion_COtype.get(co["COtype"])
co["COstart"] = TimeManager.get_web_time_str(co["COstart"])
co["COend"] = TimeManager.get_web_time_str(co["COend"])
co["COunit"] = conversion_PBunit.get(co["COunit"])
co["COgenre"] = conversion_COgenre.get(co["COgenre"])
co["COimage"] = json.loads(co["COimage"])
cm_list = self.sactive.get_cm_by_filter(
{CouponsManager.COid == coid}, set())
prid = []
for cm in cm_list:
if cm.PRid:
prid.append(cm.PRid)
co["PRids"] = prid
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = co
return response
except Exception as e:
log.error("get abo", e.message)
return SYSTEM_ERROR
def add_permission(self):
args = request.args.to_dict()
log.info("args", args)
data = json.loads(request.data)
log.info("data", data)
if "token" not in args:
return PARAMS_MISS
try:
maid = token_to_usid(args.get("token"))
except:
return TOKEN_ERROR
params_list = ["MAtelphone", "PEtype"]
for k in params_list:
if k not in data:
return PARAMS_MISS
manager = self.smanager.get_manager_by_maid(maid)
if not manager:
return TOKEN_ERROR
petype = conversion_PEtype_resverse.get(get_str(data, "PEtype"), 304)
try:
permissioner = self.smanager.get_manager_by_matelphone(data.get("MAtelphone"))
log.info("permissioner", permissioner)
if manager.MAidentity != 100:
return get_response("ERROR_MESSAGE_NO_PERMISSION", "MANAGERSYSTEMERROR", "ERROR_CODE_NO_PERMISSION")
permission = self.sapproval.get_permission_by_maid_petype(permissioner.MAid, petype)
log.info("permission", permission)
if not permission:
self.sapproval.add_model("Permission", **{
"PEid": str(uuid.uuid1()),
"PEname": data.get("PEname", ""),
"MAid": permissioner.MAid,
"PEtype": petype,
"PEsubLevel": data.get("PEsubLevel", 1)
})
else:
self.sapproval.update_permission(permission.PEid, {"PEsubLevel": data.get("PEsubLevel", 1)})
return get_response("SUCCESS_MESSAGE_ADD_DATA", "OK")
except Exception as e:
log.error("add permission", e.message)
return SYSTEM_ERROR
def add_product(self):
args = request.args.to_dict()
log.info("args", args)
data = json.loads(request.data)
log.info("data", data)
if "token" not in args:
return PARAMS_MISS
# if "PRid" not in data:
# return PARAMS_MISS
try:
maid = token_to_usid(args.get("token"))
except Exception as e:
return TOKEN_ERROR
# 库存
prid = data.get("PRid")
# todo 拆分更新
prid = prid if prid else str(uuid.uuid1())
# try:
if not self.add_brands(prid, data.get("brands"), data.get("brands_key")):
return get_response("ERROR_MESSAGE_WRONG_BRNADS", "MANAGERSYSTEMERROR", "ERROR_CODE_WRONG_BRANDS")
product = {
"PRid": prid,
"PRname": data.get("PRname", ""),
"PRvideo": data.get("PRvideo", ""),
"PRimage": json.dumps(data.get("PRimage", [])),
"PRaboimage": json.dumps(data.get("PRaboimage", "")),
"PRinfo": data.get("PRinfo", ""),
"PRvideostart": data.get("PRvideostart", ""),
"PRfranking": data.get("PRfranking", 0.0),
"MAid": maid,
"PRtype": conversion_PRtype_reverse.get(get_str(data, "PRtype", "自营")),
"PRbrand": json.dumps(data.get("PRbrand")),
"PRtime": TimeManager.get_db_time_str(),
"CTid": data.get("CTid")
}
self.sproduct.add_model("Products", **product)
self.add_approval(maid, prid)
return get_response("SUCCESS_MESSAGE_ADD_DATA", "OK")
def update_password(self):
args = request.args.to_dict()
if "token" not in args:
return PARAMS_MISS
log.info("args", args)
maid = token_to_usid(args.get("token"))
data = json.loads(request.data)
log.info("data", data)
params_key = ["MApasswordNew", "MApasswordRepeat", "MApasswordOld"]
for key in params_key:
if key not in data:
return PARAMS_MISS
new_pwd = data.get("MApasswordNew")
repeat_pwd = data.get("MApasswordRepeat")
old_pwd = data.get("MApasswordOld")
if new_pwd and repeat_pwd and new_pwd != repeat_pwd:
return get_response("ERROR_MESSAGE_WRONG_PARAMS",
"MANAGERSYSTEMERROR",
"ERROR_CODE_WRONG_PARAMS")
try:
password = self.smanager.get_manager_by_maid(maid).MApassword
log.info("password", password)
if password != old_pwd:
return get_response("ERROR_MESSAGE_WRONG_PASSWORD",
"MANAGERSYSTEMERROR",
"ERROR_WRONG_PASSWORD")
except Exception as e:
log.error("DBERROR", e.message)
return SYSTEM_ERROR
try:
result = self.smanager.update_manager(maid,
{"MApassword": new_pwd})
log.info("update result", result)
if result == 1:
return get_response("SUCCESS_MESSAGE_UPDATE_PASSWORD", "OK")
except Exception as e:
log.error("UPDATEERROR", e.message)
return SYSTEM_ERROR
def update_active_status(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
data = json.loads(request.data)
log.info("data", data)
try:
maid = token_to_usid(args.get("token"))
except:
return TOKEN_ERROR
manager = self.smanager.get_manager_by_maid(maid)
if not manager:
return TOKEN_ERROR
coid = data.get("COid")
log.info("coid", coid)
log.info("maid", maid)
costatus = conversion_COstatus_resverse.get(get_str(data, "COstatus"))
try:
cmlist = self.sactive.get_cm_by_filter(
{CouponsManager.MAid == maid, CouponsManager.COid == coid},
set())
log.info("cmlist", cmlist)
if not cmlist:
return SYSTEM_ERROR
update_result = self.sactive.update_actives(
coid, {"COstatus": costatus})
log.info("update result", update_result)
if not update_result:
return get_response("ERROR_MESSAGE_DB_ERROR",
"MANAGERSYSTEMERROR",
"ERROR_CODE_DB_ERROR")
return get_response("SUCCESS_MESSAGE_UPDATE_ORDER", "OK")
except Exception as e:
log.error("update actiave status", e.message)
return SYSTEM_ERROR
def login(self):
data = json.loads(request.data)
log.info("data", data)
param_keys = ["MAname", "MApassword"]
for key in param_keys:
if key not in data:
return PARAMS_MISS
name = get_str(data, "MAname")
password = data.get("MApassword")
if not name or not password:
return get_response("ERROR_MESSAGE_WRONG_PARAMS",
"MANAGERSYSTEMERROR",
"ERROR_CODE_WRONG_PARAMS")
try:
manager = self.smanager.get_manager_by_maname_mapassword(
name, password)
if not manager:
return get_response("ERROR_MESSAGE_WRONG_PASSWORD",
"MANAGERSYSTEMERROR",
"ERROR_WRONG_PASSWORD")
maid = manager.MAid
self.smanager.update_manager(
maid, {"MAloginTime": TimeManager.get_db_time_str()})
response = get_response("SUCCESS_MESSAGE_LOGIN", "OK")
response["data"] = {
"side": self.get_interface(maid),
"token": usid_to_token(maid),
"MAidentity": conversion_MAidentity.get(manager.MAidentity)
}
return response
except Exception as e:
log.error("LOGINERROR", e.message)
return SYSTEM_ERROR
def get_stock_all(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
maid = token_to_usid(args.get("token"))
try:
if "PBid" not in args:
prid_list = [
product.PRid
for product in self.sproduct.get_product_by_maid(maid)
]
log.info("prid list", prid_list)
pbid_list = []
for prid in prid_list:
pbid_list.extend([
productbrand.PBid for productbrand in
self.sproduct.get_productbrand_by_prid(prid)
])
log.info("pbid list", pbid_list)
stocks_list = []
for pbid in pbid_list:
stock_product_list = tolist(
self.sstocks.get_stocks_by_PBid(pbid))
log.info("stock_product_list", stock_product_list)
for stock_product in stock_product_list:
stock = todict(
self.sstocks.get_stock_by_stid(
stock_product.get("STid")))
log.info("stock", stock)
stock_product.update(stock)
stocks_list.extend(stock_product_list)
else:
stocks_list = tolist(
self.sstocks.get_stocks_by_PBid(args.get("PBid")))
for stock_product in stocks_list:
stock = todict(
self.sstocks.get_stock_by_stid(
stock_product.get("STid")))
stock_product.update(stock)
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = stocks_list
return response
except Exception as e:
log.error("get error", e.message)
return SYSTEM_ERROR
def get_ctlist_by_ctid(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args or "CTid" not in args:
return PARAMS_MISS
ct_filter = {Category.CTid == args.get("CTid")}
parentid_list = [
ct.get("CTfromid")
for ct in tolist(self.scategory.get_category_by_or_filter(set()))
]
if args.get("CTid") in parentid_list:
return get_response("ERROR_MESSAGE_DB_ERROR", "MANAGERSYSTEMERROR",
"ERROR_CODE_DB_ERROR")
ct_list = []
while True:
ct = tolist(self.scategory.get_category_by_or_filter(ct_filter))[0]
ct_list.insert(0, ct)
if ct.get("CTfromid") == "0":
break
ct_filter = {Category.CTid == ct.get("CTfromid")}
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = ct_list
return response
def update_product_status(self):
args = request.args.to_dict()
log.info("args", args)
maid = token_to_usid(args.get("token"))
if "token" not in args:
return PARAMS_MISS
data = json.loads(request.data, encoding="utf8")
log.info("data", data)
if "PRstatus" not in data or "PRid" not in data:
return PARAMS_MISS
prstatus = get_str(data, "PRstatus")
pridlist = data.get("PRid")
self.on_or_off_shelves(pridlist, conversion_PBstatus_reverse.get(prstatus), maid)
return get_response("SUCCESS_MESSAGE_UPDATE_DATA", "OK")
def get_managers(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
page_size = int(args.get("page_size"))
page_num = int(args.get("page_num"))
or_filter = set()
if "MAfilter" in args:
from ManagerSystem.models.model import Manager
or_filter.add(
Manager.MAnicname.like("%{0}%".format(get_str(
args, "MAfilter"))))
or_filter.add(
Manager.MAemail.like("%{0}%".format(get_str(args,
"MAfilter"))))
maid = token_to_usid(args.get("token"))
try:
pn, count = self.check_page_value(page_num,
page_size, "model.Manager.MAid",
set(), or_filter)
start_num = (pn - 1) * page_size
manager = self.smanager.get_manager_by_maid(maid)
if not manager:
return SYSTEM_ERROR
manager_list = tolist(
self.smanager.get_managers(start_num, page_size, or_filter))
for manager in manager_list:
manager["MAidentity"] = conversion_MAidentity.get(
manager.get("MAidentity"))
manager["MAstatus"] = conversion_MAstatus.get(
manager.get("MAstatus"))
manager["MAloginTime"] = TimeManager.get_web_time_str(
manager.get("MAloginTime"))
manager["MAcreatTime"] = TimeManager.get_web_time_str(
manager.get("MAcreatTime"))
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = {
"count": count,
"page_num": pn,
"page_size": page_size,
"Managers": manager_list
}
return response
except Exception as e:
log.error("get managers", e.message)
return SYSTEM_ERROR
def get_first(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
category_filter = {Category.CTfromid == "0"}
try:
cate_list = tolist(
self.scategory.get_category_by_or_filter(category_filter))
log.info("cate list", cate_list)
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = cate_list
return response
except Exception as e:
log.error("get first", e.message)
return SYSTEM_ERROR
def apply_manager(self):
data = json.loads(request.data)
log.info("data", data)
param_keys = ["MAtelphone"]
for params in param_keys:
if params not in data:
return PARAMS_MISS
manager_key = [
"MAname", "MAtelphone", "MAemail", "MAidentity", "MApassword",
"MAstatus", "MAcreatTime", "MAendTime", "MAidNumber",
"MAidImageFront", "MAidImageReverse", "MAbusinessLicense",
"MAcredit"
]
manager = {}
for key in manager_key:
if key in data:
manager[key] = data.get(key)
MAid = str(uuid.uuid1())
manager["MAid"] = MAid
maname = "商家{0}".format(data.get(
"MAtelphone")) if not data.get("MAname") else data.get("MAname")
manager["MAname"] = maname
manager["MApassword"] = self.create_password()
manager["MAidentity"] = conversion_MAidentity_reverse.get(
data.get("MAidentity", "卖家"))
manager["MAcreatTime"] = TimeManager.get_db_time_str()
manager["MAendTime"] = TimeManager.get_db_time_str(
data.get("MAendTime"))
manager["MAstatus"] = conversion_MAstatus_resverse.get(
data.get("MAstatus", "可用"))
try:
self.smanager.add_model("Manager", **manager)
except Exception as e:
log.error("add manager error", e.message)
return SYSTEM_ERROR
response = get_response("SUCCESS_MESSAGE_REGISTER", "OK")
response["data"] = {
"MAname": maname,
"MApassword": manager["MApassword"]
}
return response
def get_approval(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
try:
maid = token_to_usid(args.get("token"))
except:
return TOKEN_ERROR
page_size = int(args.get("page_size"))
page_num = int(args.get("page_num"))
approval_filter = {
Approval.APreceive == maid,
}
if args.get("APname"):
approval_filter.add(Approval.APname.like("%{0}%".format(get_str(args, "APname"))))
if args.get("APstart"):
apstart = [ma.MAid for ma in self.smanager.get_manager_by_name(args.get("APstart"))]
approval_filter.add(Approval.APstart.in_(apstart))
pn, count = self.check_page_value(page_num, page_size, "model.Approval.APid", approval_filter, set())
start_num = (pn - 1) * page_size
try:
approval_list = tolist(self.sapproval.get_approval_by_and_filter(start_num, page_size, approval_filter))
log.info("approval", approval_list)
for approval in approval_list:
approval["APstatus"] = conversion_APstatus.get(approval.get("APstatus", 441))
approval["PEtype"] = conversion_PEtype.get(approval.get("PEtype", 304))
manager = self.smanager.get_manager_by_maid(approval.get("APstart"))
log.info("manager", manager)
approval["APstart"] = manager.MAname
approval["APtime"] = TimeManager.get_web_time_str(approval.get("APtime"))
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["data"] = {
"approvals": approval_list,
"count": count,
"page_size": page_size,
"page_num": page_num
}
return response
except Exception as e:
log.error("get approval", e.message)
return SYSTEM_ERROR
def add_stock_product(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args:
return PARAMS_MISS
data = json.loads(request.data)
log.info("data", data)
sp = {"SPid": str(uuid.uuid1())}
for key in self.stock_product_key_list:
if key not in data:
return PARAMS_MISS
sp[key] = data.get(key)
try:
self.sstocks.add_model("StocksProducts", **sp)
return get_response("SUCCESS_MESSAGE_ADD_DATA", "OK")
except Exception as e:
log.error("add stock product error", e.message)
return SYSTEM_ERROR
def get_categorybrands(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args or "CTid" not in args:
return PARAMS_MISS
ctid = get_str(args, "CTid")
try:
category_filter = {CategoryBrand.CTid == ctid}
cb_list = tolist(
self.scategory.get_categorybrands_by_filter(category_filter))
log.info("cb list", cb_list)
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
for cb in cb_list:
if cb.get("CBvalue"):
cb["CBvalue"] = str.split(get_str(cb, "CBvalue"), ",")
response["data"] = cb_list
return response
except Exception as e:
log.error("get categprybrands", e.message)
return SYSTEM_ERROR
def _get_order_abo_by_order_main(self, order_main):
order_part_list = tolist(
self.sorder.get_order_part_list_by_omid(order_main.get("OMid")))
for order_part in order_part_list:
order_part.update(
self._get_product_into_order_abo(order_part.get("PBid")))
order_main["order_abo"] = order_part_list
order_main["OMcointype"] = cvs.conversion_PBunit.get(
order_main.get("OMcointype"), "其他币种")
order_main["OMstatus"] = cvs.conversion_OMstatus.get(
order_main.get("OMstatus"), 0)
order_main["OMtime"] = TimeManager.get_web_time_str(
order_main.get("OMtime"))
location = todict(
self.sorder.get_location_by_loid(order_main.get("LOid")))
if location.get("LOisedit") == 303:
print(get_response("ERROR_MESSAGE_GET_LOCATION",
"WORING_LOCATION"))
order_main.update(location)
order_main["CAid"] = order_main.pop("COid")
