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_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_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_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 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 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 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 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 _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")
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_brands(self, prid):
pblist = tolist(self.sproduct.get_pball_by_prid(prid))
log.info("pblist", pblist)
brandskey = []
for pb in pblist:
brid = pb.get("BRid")
brand = self.sproduct.get_brand_by_brid(brid)
pbnumber_list = [st.PBnumber for st in self.stock.get_stocks_by_PBid(pb.get("PBid"))]
log.info("pbnumber_list", pbnumber_list)
brands = []
while brid != "0":
if brand.BRkey not in brandskey:
brandskey.append(brand.BRkey)
brands.append(brand.BRvalue)
brid = brand.BRfromid
brand = self.sproduct.get_brand_by_brid(brid)
pb["BRands"] = brands
pb['PBstatus'] = conversion_PBstatus.get(pb.get("PBstatus"))
pb["PBunit"] = conversion_PBunit.get(pb.get("PBunit"))
pb["PBnumber"] = sum(pbnumber_list)
return pblist, brandskey
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_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 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
