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_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 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_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 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 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 add_category(self):
args = request.args.to_dict()
log.info("args", args)
data = json.loads(request.data)
if "token" not in args:
return PARAMS_MISS
# todo 权限审核
try:
maid = token_to_usid(args.get("token"))
except:
return TOKEN_ERROR
ctfromid = "0"
if "CTid" in data:
ctfromid = get_str(data, "CTid")
try:
ctid = str(uuid.uuid1())
cateary = {
"CTid": ctid,
"CTfromid": ctfromid,
"MAid": maid,
"CTname": data.get("CTname")
}
self.scategory.add_model("Category", **cateary)
except Exception as e:
log.error("add category", 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 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_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 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_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_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_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 get_order_abo(self):
try:
args = request.args.to_dict()
log.info("args", args)
if "token" not in args or "OMid" not in args:
return PARAMS_MISS
maid = token_to_usid(args.get("token"))
if not maid:
return TOKEN_ERROR
order_main = todict(
self.sorder.get_order_main_by_om_id(get_str(args, "OMid")))
order_main.pop("USid")
self._get_order_abo_by_order_main(order_main)
log.info("order main", order_main)
data = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
data["data"] = order_main
return data
except Exception as e:
log.error("get order abo", 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_order_list(self):
try:
args = request.args.to_dict()
log.info("args", args)
if "token" not in args or "page_size" not in args or "page_num" not in args:
return PARAMS_MISS
page_size = int(args.get("page_size"))
page_num = int(args.get("page_num"))
maid = token_to_usid(args.get("token"))
from ManagerSystem.models.model import Products
product_filter = {Products.MAid == maid}
if args.get("PRname"):
product_filter.add(
Products.PRname.like("%{0}%".format(get_str(
args, "PRname"))))
product_list = tolist(
self.sproduct.get_product_by_filter(product_filter))
log.info("product list ", product_list)
pb_list = []
for product in product_list:
product["PBunit"] = cvs.conversion_PBunit.get(
product.get("PBunit", "其他币种"))
product["PRbrand"] = cvs.conversion_PRbrand.get(
product.get("PRbrand"), "其他")
product["PRtype"] = cvs.conversion_PRtype.get(
product.get("PRtype"))
for pb in tolist(
self.sproduct.get_pball_by_prid(product.get("PRid"))):
pb.update(product)
pb_list.append(pb)
log.info("pb_list", pb_list)
om_list = []
om_id_dict = {}
from ManagerSystem.models.model import OrderMain
omfilter = set()
if args.get("OMstatus"):
omstatus = cvs.conversion_OMstatus_reverse.get(
get_str(args, "OMstatus"))
omfilter.add(OrderMain.OMstatus == omstatus)
if args.get("OMlogisticsName"):
omfilter.add(OrderMain.OMlogisticsName == get_str(
args, "OMlogisticsName"))
if args.get("OMstartTime"):
omfilter.add(OrderMain.OMtime >= TimeManager.get_db_time_str(
args.get("OMstartTime")))
if args.get("OMendTime"):
omfilter.add(OrderMain.OMtime <= TimeManager.get_db_time_str(
args.get("OMendTime")))
for pb in pb_list:
op_pb_list = tolist(
self.sorder.get_order_part_list_by_pbid(pb.get("PBid")))
for op_pb in op_pb_list:
op_pb.update(pb)
if op_pb.get("OMid") in om_id_dict:
om_id_dict[op_pb.get("OMid")].append(op_pb)
else:
om_id_dict[op_pb.get("OMid")] = [op_pb]
log.info("om_id_dict", om_id_dict)
om_count = {k: 0 for k in cvs.conversion_OMstatus}
for om_id in om_id_dict:
if args.get("OMid") and args.get("OMid") not in om_id:
continue
omfilter_tmp = omfilter.copy()
omfilter_tmp.add(OrderMain.OMid == om_id)
om_dict = tolist(self.sorder.get_om_by_filter(omfilter_tmp))
if not om_dict:
continue
om_dict = om_dict[0]
om_dict.update({"order_item": om_id_dict.get(om_id)})
location = todict(
self.sorder.get_location_by_usid(om_dict.pop("USid")))
log.info("location", location)
om_count[om_dict.get("OMstatus")] += 1
om_dict.update(location)
om_dict["OMcointype"] = cvs.conversion_PBunit.get(
om_dict.get("OMcointype"), "其他币种")
om_dict["OMstatus"] = cvs.conversion_OMstatus.get(
om_dict.get("OMstatus"), 0)
om_dict["OMtime"] = TimeManager.get_web_time_str(
om_dict.get("OMtime"))
om_list.append(om_dict)
log.info("omlist", om_list)
count = len(om_list)
if page_size * page_num > count:
page_num = count / page_size + 1
page_num = page_num if page_num > 0 else 1
om_list = om_list[(page_num - 1) * page_size:page_num * page_size]
data = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
data["data"] = {
"count": count,
"page_num": page_num,
"page_size": page_size,
"OrderMains": om_list,
"OMcount": om_count
}
return data
except Exception as e:
log.error("get order list", e.message)
import traceback
print(traceback.format_exc())
return SYSTEM_ERROR
def get_active(self):
args = request.args.to_dict()
log.info("args", args)
params_key = ["token", "page_size", "page_num", "COgenre"]
for key in params_key:
if key 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
page_num = int(args.get("page_num"))
page_size = int(args.get("page_size"))
start_time = ""
end_time = ""
if args.get("COstart"):
start_time = TimeManager.get_db_time_str(args.get("COstart"))
if args.get("COend"):
end_time = TimeManager.get_db_time_str(args.get("COend"))
amfilter = {CouponsManager.MAid == maid}
cm_dict = {}
for cm in self.sactive.get_cm_by_filter(amfilter, set()):
if cm.COid not in cm_dict:
cm_dict[cm.COid] = [cm.PRid]
else:
cm_dict[cm.COid].append(cm.PRid)
active_list = []
for coid in cm_dict:
am_tmp_filter = {
CouponsActives.COid == coid,
CouponsActives.COgenre == conversion_COgenre_resverse.get(
get_str(args, "COgenre")), CouponsActives.COstatus != 560
}
ca_list = tolist(
self.sactive.get_actives_by_filter(am_tmp_filter, set()))
for ca in ca_list:
if args.get("COname") and get_str(
args, "COname") not in get_str(ca, "COname"):
continue
if args.get("COid") and get_str(args, "COid") not in get_str(
ca, "COid"):
continue
if args.get("COstatus") and conversion_COstatus_resverse.get(
get_str(args, "COstatus")) != ca.get("COstatus"):
continue
if start_time and start_time > ca.get("COend"):
continue
if end_time and end_time < ca.get("COstart"):
continue
if args.get("COtype") and conversion_COtype_resverse.get(
get_str(args, "COtype")) != ca.get("COtype"):
continue
ca["COstatus"] = conversion_COstatus.get(ca["COstatus"])
ca["duration"] = TimeManager.get_delta_time(
ca["COstart"], ca["COend"])
ca["COstart"] = TimeManager.get_web_time_str(ca["COstart"])
ca["COend"] = TimeManager.get_web_time_str(ca["COend"])
ca["COunit"] = conversion_PBunit.get(ca["COunit"])
ca["COtype"] = conversion_COtype.get(ca.get("COtype"))
ca["PRids"] = cm_dict.get(coid)
ca["COimage"] = json.loads(ca["COimage"])
ca["get_num"] = len(
self.sactive.get_cp_by_filter({Cardpackage.COid == coid},
set()))
active_list.append(ca)
count = len(active_list)
if page_size * page_num > count:
page_num = count / page_size + 1
active_list = active_list[(page_num - 1) * page_size:page_num *
page_size]
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response["count"] = count
response["page_size"] = page_size
response["page_num"] = page_num
response["CouponsActives"] = active_list
return response
def add_brands(self, prid, brands, brands_key):
if not isinstance(brands, list):
return False
for i in brands:
brid = ""
brand_values = i.get("BRands")
if len(brand_values) != len(brands_key):
return False
BRfromid = 0
for index, key in enumerate(brands_key):
brandid = [br.BRid for br in self.sproduct.get_brid_by_key_value(key, brand_values[index])]
if brandid:
if not BRfromid:
if len(brandid) != 1:
return False
BRfromid = brandid[0]
else:
BRfromid_tmp = [brfrom for brfrom in brandid if self.sproduct.get_brfromid_by_brid(brfrom) == BRfromid]
if BRfromid_tmp:
BRfromid = BRfromid_tmp[0]
else:
brid = str(uuid.uuid1())
self.sproduct.add_model("Brands", **{
"BRid": brid,
"BRfromid": BRfromid,
"BRvalue": brand_values[index],
"BRkey": key
})
BRfromid = brid
else:
brid = str(uuid.uuid1())
self.sproduct.add_model("Brands", **{
"BRid": brid,
"BRfromid": BRfromid,
"BRvalue": brand_values[index],
"BRkey": key
})
BRfromid = brid
if not brid:
brid = BRfromid
from ManagerSystem.config.conversion import conversion_PBstatus_reverse
stid = str(uuid.uuid1())
pbid = str(uuid.uuid1())
self.stock.add_model("Stocks", STid=stid, STname="库存"+prid, STamout=10 * 10 * 10 * 10 * 10 * 10)
self.stock.add_model("StocksProducts", SPid=str(uuid.uuid1()), STid=stid, PBid=pbid, PBnumber=i.get("PBnumber"))
self.sproduct.add_model("ProductsBrands", **{
"PBid": pbid,
"PRid": prid,
"BRid": brid,
"PBprice": i.get("PBprice"),
"PBunit": conversion_PBunit_reverse.get(get_str(i, "PBunit", "$")),
"PBimage": i.get("PBimage"),
"PBstatus": conversion_PBstatus_reverse.get(get_str(i, "PBstatus", "在售状态")),
"PBsalesvolume": 0,
"PBscore": 0,
})
return True
def get_situation(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
manager = self.smanager.get_manager_by_maid(maid)
if not manager:
return TOKEN_ERROR
# start_time = int(args.get("days", 1))
end_time = TimeManager.get_db_time_str(args.get("end_time"))
start_time = TimeManager.get_db_time_str(args.get("start_time"))
try:
cm_list = self.sactive.get_cm_by_filter(
{CouponsManager.MAid == maid}, set())
log.info("cm list", cm_list)
coid_list_all = {}.fromkeys([cm.COid for cm in cm_list]).keys()
# timefilter = TimeManager.get_forward_time_web(days=-days)
cogenre = conversion_COgenre_resverse.get(get_str(args, "COgenre"))
log.info("COgenre", cogenre)
# 筛选优惠券/活动
coid_list_filter = []
for coid in coid_list_all:
ca = self.sactive.get_actives_by_filter(
{CouponsActives.COid == coid}, set())
log.info("ca", ca)
if ca:
ca = ca[0]
if ca.COgenre != cogenre:
continue
coid_list_filter.append(ca.COid)
om_list = self.sorder.get_om_by_filter(set())
used_sum = 0
for om in om_list:
if om.COid in coid_list_filter and end_time > om.OMtime > start_time:
used_sum += 1
cp_list = self.sactive.get_cp_by_filter(set(), set())
get_num = 0
for cp in cp_list:
if cp.COid in coid_list_filter and end_time > cp.CPtime > start_time:
get_num += 1
data_dict = {}
days = TimeManager.get_delta_days(start_time, end_time)
log.info("days", days + 1)
for i in range(0, days + 1):
sub_time_filter_start = TimeManager.get_forward_time_web(
days=-(i + 1))
sub_time_filter_end = TimeManager.get_forward_time_web(days=-i)
sub_om_num = 0
for om in om_list:
if om.COid in coid_list_filter and sub_time_filter_end < om.OMtime < sub_time_filter_start:
sub_om_num += 1
sub_cp_num = 0
for cp in cp_list:
sub_cp_num += 1
if cp.COid in coid_list_filter and sub_time_filter_end < cp.CPtime < sub_time_filter_start:
sub_cp_num += 1
data_dict[sub_time_filter_start] = [sub_om_num, sub_cp_num]
response = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
params = [
{
"name": "领取张数",
"value": get_num
},
{
"name": "使用张数",
"value": used_sum
},
]
response["data"] = {"params": params, "data": data_dict}
return response
except Exception as e:
log.error("get situation", e.message)
return SYSTEM_ERROR
def get_info_by_id(self):
args = request.args.to_dict()
log.info("args", args)
params_key_list = ["PRid", "token"]
for param_key in params_key_list:
if param_key not in args:
return PARAMS_MISS
PRid = args["PRid"]
maid = args.get("token")
product = self.sproduct.get_product_by_prid(PRid)
log.info("product", product)
if not product:
return SYSTEM_ERROR
from ManagerSystem.service.SCategory import SCategory
from ManagerSystem.models.model import CategoryBrand
category_filter = {
CategoryBrand.CTid == product.CTid
}
category = tolist(SCategory().get_categorybrands_by_filter(category_filter))
log.info("cb list", category)
for cb in category:
if cb.get("CBvalue"):
cb["CBvalue"] = str.split(get_str(cb, "CBvalue"), ",")
product_price = [9999999, -1]
product_volue = 0
product_price_list =[
pro.PBprice for pro in self.sproduct.get_pbprice_by_prid(PRid)]
log.info("product_price_list", product_price_list)
if not product_price_list:
return SYSTEM_ERROR
for row in product_price_list:
if row < product_price[0]:
product_price[0] = row
if row > product_price[1]:
product_price[1] = row
product_price = [str(i) for i in product_price]
prprice = "-".join(product_price) \
if product_price[0] != product_price[1] \
else product_price[0]
product_volue_list = [pro.PBsalesvolume for pro in
self.sproduct.get_pbvolume_by_prid(PRid)]
log.info('product_volue_list', product_volue_list)
if not product_volue_list:
return SYSTEM_ERROR
for row in product_volue_list:
product_volue = product_volue + row
product_info = {}
product_info["PRid"] = PRid
product_info["PRprice"] = prprice
product_info["PRsalevolume"] = product_volue
product_info["PRname"] = product.PRname
product_info["PRvideo"] = product.PRvideo
product_info["PRfranking"] = product.PRfranking
product_info["PRinfo"] = product.PRinfo
product_info["PRvideostart"] = product.PRvideostart
product_info["PRimage"] = json.loads(product.PRimage)
product_info["PRaboimage"] = json.loads(product.PRaboimage)
PRbrand = product.PRbrand
PRtype = product.PRtype
product_info["PRbrand"] = json.loads(PRbrand)
product_info["PRtype"] = conversion_PRtype.get(PRtype)
brands, brands_key = self.get_brands(PRid)
product_info["brands"] = brands
product_info["brands_key"] = brands_key
response_of_product = get_response("SUCCESS_MESSAGE_GET_PRODUCT", "OK")
response_of_product["data"] = {
"category": category,
"product_info": product_info
}
return response_of_product
def get_all(self):
args = request.args.to_dict()
log.info("args", args)
if "token" not in args or "page_size" not in args or "page_num" not in args:
return PARAMS_MISS
page_size = int(args.get("page_size"))
page_num = int(args.get("page_num"))
maid = token_to_usid(args.get("token"))
from ManagerSystem.models.model import Products
pro_fillter = {Products.MAid == maid}
sub_filter = set()
if args.get("product_filter"):
product_filter = get_str(args, "product_filter")
sub_filter = {
Products.PRname.like("%{0}%".format(product_filter)),
Products.PRinfo.like("%{0}%".format(product_filter))
}
pn, count = self.check_page_value(page_num, page_size, "model.Products.PRid", pro_fillter, sub_filter)
start_num = (pn - 1) * page_size
PRid_list = [products.PRid for products in self.sproduct.get_all_prid(start_num, page_size, pro_fillter, sub_filter)]
log.info("PRid list", PRid_list)
pbstatus = get_str(args, "PBstatus")
# todo 增加遍历输出所有图片
# htv = float(args.get("htv", 0.48))
# from ManagerSystem.common.Gethdp import get_hdp
# hdp = get_hdp(htv)
product_infos = []
for PRid in PRid_list:
product = todict(self.sproduct.get_product_by_prid(PRid))
log.info("product", product)
if not product:
return SYSTEM_ERROR
product["PRid"] = PRid
product["PRimage"] = json.loads(product.get("PRimage"))
product["PRaboimage"] = json.loads(product.get("PRaboimage"))
product["PRtype"] = conversion_PRtype.get(get_str(product, "PRtype"))
product["PRtime"] = TimeManager.get_web_time_str(product.get("PRtime"))
product["PRbrand"] = json.loads(product.get("PRbrand"))
log.info("pbstatus", pbstatus)
saleamount = 0
stockamout = 0
if not pbstatus:
pb_list = tolist(self.sproduct.get_pball_by_prid(PRid))
else:
pb_list = tolist(self.sproduct.get_pball_by_prid_pbstatus(PRid, conversion_PBstatus_reverse.get(pbstatus)))
PRstatus = ""
for pb in pb_list:
saleamount += int(pb.get("PBsalesvolume"))
PRstatus = conversion_PBstatus.get(pb.get("PBstatus"))
stockamout += sum([int(st.get("PBnumber", 0)) for st in tolist(self.stock.get_stocks_by_PBid(pb.get("PBid")))])
pb.update(product)
if not PRstatus:
count -= 1
continue
# product_infos.extend(pb_list)
product["PRsalesvolume"] = saleamount
product["PRstock"] = stockamout
product["PRstatus"] = PRstatus
product_infos.append(product)
response_of_product = get_response("SUCCESS_MESSAGE_GET_INFO", "OK")
response_of_product["data"] = {
"count": count,
"page_num": page_num,
"page_size": page_size,
"products": product_infos
}
log.info("response", response_of_product)
return response_of_product
def update_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)
params = ["APid", "APaction", 'APremark']
for key in params:
if key not in data:
return PARAMS_MISS
try:
maid = token_to_usid(args.get("token"))
except:
return TOKEN_ERROR
try:
approval = todict(self.sapproval.get_approval_by_apid(data.get("APid")))
log.info("approval", approval)
petype = approval.get("PEtype")
apaction = get_str(data, "APaction")
pemaxlevel = self.sapproval.get_max_level(petype)
log.info("max level", pemaxlevel)
permission = self.sapproval.gert_pemission_by_maid_petype(maid, petype)
log.info("permission", permission)
manager = todict(self.smanager.get_manager_by_maid(maid))
apremark = get_str(approval, "APremark", "") + "\n" + get_str(manager, "MAname") + ":\n" + get_str(data, "APremark", "")
log.info("apremark", apremark)
update_approval = {
"APid": str(uuid.uuid1()),
"APname": approval.get("APname"),
"APremark": apremark,
"APstart": approval.get("APstart"),
"APtime": approval.get("APtime"),
"APcontent": approval.get("APcontent"),
"PEtype": approval.get("PEtype")
}
recevie_list = []
if apaction == "同意":
if pemaxlevel == permission.PEsubLevel:
update_approval["APstatus"] = 445
self.dealapproval(petype, data.get("APcontent"))
self.sapproval.update_approval_by_name(approval.get("APname"), {"APstatus": 445, "APremark": apremark})
else:
update_approval["APstatus"] = 443
self.sapproval.update_approval_by_name(approval.get("APname"), {"APstatus": 442, "APremark": apremark})
recevie_list = self.sapproval.get_permission_by_petype_pesublevel(petype, permission.PEsubLevel + 1)
else:
update_approval["APstatus"] = 444
update_approval["APreceive"] = approval.get("APstart")
self.sapproval.update_approval_by_name(approval.get("APname"), {"APstatus": 444, "APremark": apremark})
if recevie_list:
for recevie in recevie_list:
update_approval["APreceive"] = recevie.MAid
self.sapproval.add_model("Approval", **update_approval)
else:
self.sapproval.add_model("Approval", **update_approval)
return get_response("SUCCESS_MESSAGE_UPDATE_DATA", "OK")
except Exception as e:
log.error("update approval", e.message)
return SYSTEM_ERROR
def add_active(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
params_list = ["COname", "COabo", "COtype", "COstart", "COend"]
for key in params_list:
if key not in data:
return PARAMS_MISS
acstart = TimeManager.get_db_time_str(get_str(data, "COstart"))
acend = TimeManager.get_db_time_str(get_str(data, "COend"))
if acstart >= acend:
return get_response("ERROR_MESSAGE_TIME_ERROR",
"MANAGERSYSTEMERROR", "ERROR_CODE_TIME_ERROR")
coid = str(uuid.uuid1())
CA = {
"COid":
coid,
"COabo":
get_str(data, "COabo"),
"COimage":
json.dumps(data.get("COimage")),
"COname":
get_str(data, "COname"),
"COstatus":
conversion_COstatus_resverse.get(get_str(data, "COstatus"), 550),
"COstart":
acstart,
"COend":
acend,
"COfilter":
data.get("COfilter", 0),
"COother":
get_str(data, "COother"),
"COdiscount":
data.get("COdiscount", 1),
"COamount":
data.get("COamount", 0),
"COtype":
conversion_COtype_resverse.get(get_str(data, "COtype")),
"COnumber":
data.get("COnumber", 0),
"COgenre":
conversion_COgenre_resverse.get(get_str(data, "COgenre")),
"COunit":
conversion_PBunit_reverse.get(get_str(data, "COunit"), 402),
"COtime":
TimeManager.get_db_time_str(),
"COuserfilter":
data.get("COuserfilter", 0),
"COotherType":
data.get("COotherType", "0")
}
log.info("CA", CA)
try:
self.sactive.add_model("CouponsActives", **CA)
except Exception as e:
log.error("add CA", e.message)
return SYSTEM_ERROR
try:
prid_list = data.get("PRids")
if prid_list:
for prid in prid_list:
self.sactive.add_model(
"CouponsManager", **{
"CMid": str(uuid.uuid1()),
"COid": coid,
"MAid": maid,
"PRid": prid,
"CMprobability": data.get("CMprobability", 1)
})
else:
self.sactive.add_model(
"CouponsManager", **{
"CMid": str(uuid.uuid1()),
"COid": coid,
"MAid": maid,
"PRid": "",
"CMprobability": data.get("CMprobability", 1)
})
response = get_response("SUCCESS_MESSAGE_ADD_DATA", "OK")
response["data"] = coid
return response
except Exception as e:
log.error("add CM", e.message)
return SYSTEM_ERROR
