def select_adgroup(query_dict, opt_list, opt_cmd_str, user_id, request = None):
"""基于adgroup生成任务"""
from apps.crm.models import UserOrder
from apps.mnt.models import MntTaskMng
from apps.subway.models_adgroup import adg_coll
try:
query_dict = json.loads(query_dict)
psuser_id = int(user_id)
adg_list = list(adg_coll.find(query_dict, {'shop_id':1, 'campaign_id':1, '_id':1}))
if not adg_list:
return {'result':'查询不到对象，无法操作!'}
else:
adg_dict = {}
for adg in adg_list:
temp_key = '%s-%s' % (adg['shop_id'], adg['campaign_id'])
if temp_key not in adg_dict:
adg_dict[temp_key] = []
adg_dict[temp_key].append(adg['_id'])
uo = UserOrder.create_order(psuser_id = psuser_id, command_detail = opt_cmd_str, query_dict = str(query_dict), from_source = 0)
if not uo:
return {'result':'命令已生成！'}
uo.task_id_list = MntTaskMng.generate_task_bycmd(adg_dict = adg_dict, opt_list = json.loads(opt_list), reporter = uo.id) # 注意：参数中一些int型的，页面上传回来是str，注意在函数中强转
uo.save()
return {'result':'命令生成成功！'}
except Exception, e:
return {'result':'命令生成失败，原因：%s' % e}
def get_creatives_byadgids(cls,
shop_id,
tapi,
adg_id_list=None,
transfer_flag=False):
"""通过adg_id_list获取对应的creative_list"""
if not adg_id_list:
adg_id_list = list(
adg['_id']
for adg in adg_coll.find({'shop_id': shop_id}, {'_id': 1}))
creative_list = []
for adg_id in adg_id_list:
creative_list.extend(
cls.__get_creatives_byadg(shop_id=shop_id,
adgroup_id=adg_id,
tapi=tapi))
if transfer_flag: # 是否需要将top_obj转成标准含所有信息的字典
temp_list = []
for creative in creative_list:
temp_list.append(
cls.Parser.parse(creative,
trans_type='init',
extra_dict={'shop_id': shop_id}))
return temp_list
else:
return creative_list
def get_all_adgroup_idlist(self):
adg_cur = adg_coll.find({
'shop_id': self.shop_id,
'campaign_id': self.campaign_id,
'mnt_type': self.mnt_type
})
adgroup_id_list = [adg['_id'] for adg in adg_cur]
return adgroup_id_list
def batch_refresh_shopcatid(shop_id_list, is_force = False):
# 批量刷新店铺的类目ID
def get_shop_cat(category_ids_list):
cat_id = 0
if category_ids_list:
tmp_dict = {}
for category_ids in category_ids_list:
tmp_cat_list = category_ids.split()[:1]
for tmp_cat in tmp_cat_list:
if not tmp_dict.has_key(tmp_cat):
tmp_dict[tmp_cat] = 1
else:
tmp_dict[tmp_cat] += 1
# 将字典排序成按出现次数最多的元组排序
sorted_list = sorted(tmp_dict.iteritems(), key = lambda x:x[1], reverse = True)
cat_id = sorted_list[0][0] # 只取第一个
return cat_id
temp_shop_dict = {}
temp_cat_dict = {}
if not is_force:
shop_id_list = [ int(acc['_id']) for acc in account_coll.find({'_id':{'$in':shop_id_list}, '$or':[{'cat_id':None}, {'cat_id':0}, {'cat_id':''}]}, {'_id':1}) ]
if not shop_id_list:
return {}, 0
adg_cursor = adg_coll.find({'shop_id':{'$in':shop_id_list}}, {'category_ids':1, 'shop_id':1})
for adg in adg_cursor:
if adg:
key = str(adg['shop_id'])
if temp_shop_dict.has_key(key):
temp_shop_dict[key].append(adg['category_ids'])
else:
temp_shop_dict[key] = [adg['category_ids']]
for shop_id, category_ids_list in temp_shop_dict.items():
cat_id = get_shop_cat(category_ids_list)
key = str(cat_id)
if temp_cat_dict.has_key(key):
temp_cat_dict[key].append(int(shop_id))
else:
temp_cat_dict[key] = [int(shop_id)]
count = 0
result = {}
for cat_id, shop_id_list in temp_cat_dict.items():
result_dict = account_coll.update({'_id':{'$in':shop_id_list}}, {'$set':{'cat_id':int(cat_id)}}, upsert = False, multi = True)
# Customer.objects.filter(shop_id__in = shop_id_list).update(cat_id = int(cat_id))
# log.info('have already refreshed, cat_id = %s , shop_id_list = %s, result_dict=%s' % (cat_id, shop_id_list, json.dumps(result_dict)))
if result_dict and result_dict.has_key('n'):
count += result_dict['n']
result_dict['cat_id'] = cat_id
result = result_dict
return result, count
def force_download_rpt(cls, shop_id, tapi, token, time_scope):
"""给出时间区间，强制下载"""
adg_tuple_list = [(adg['_id'], adg['campaign_id'], time_scope[0])
for adg in adg_coll.find({'shop_id': shop_id}, {
'_id': 1,
'campaign_id': 1
})]
result, _ = cls.download_crtrpt_byadgs(shop_id=shop_id,
tapi=tapi,
token=token,
adg_tuple_list=adg_tuple_list)
return result
def check_adgroup(adg_id):
example_cat_std_click = 100
example_cat_click = get_cat_click_8id(150704)
adg = Adgroup.objects.get(adgroup_id = adg_id)
camp = Campaign.objects.get(online_status = 'online', campaign_id = adg.campaign_id)
adg_rpt_dict = {adg['_id']:AdgroupHelper(**adg) for adg in adg_coll.find({'online_status': 'online', '_id': adg_id})}
item = adg.item
adg_rpt_data = adg_rpt_dict[adg_id]
cat_data = adg.cat_data
kw_list = Keyword.objects.only('word').filter(adgroup_id = adg.adgroup_id)
kw_count = len(kw_list)
avg = get_avg_qscore(kw_list, adg.adgroup_id)
rate = get_qscore_rate(kw_list, adg.adgroup_id)
avg_click_7_day = adg_rpt_data.click7 / 7
cat_click = get_cat_all_click(item, cat_data)
ppc = adg_rpt_data.cpc7
roi = adg_rpt_data.roi7
cat_avg_ppc = get_cat_avg_cpc(item, cat_data)
cat_avg_conv = get_cat_avg_conv(item, cat_data)
result = calc_kw_1(adg)
ctr = adg_rpt_data.ctr7
cat_avg_ctr = get_cat_avg_ctr(item, cat_data)
conv = adg_rpt_data.conv7
cat_avg_conv = get_cat_avg_conv(item, cat_data)
if kw_count < 100: # 词少， 关键词少于100个
log.info('camp_id=%s adg_id=%s kw_count=%s' % (camp.campaign_id, adg.adgroup_id, kw_count))
print '词少， 关键词少于100个'
if avg and rate and avg < 6.5 and rate > 0.4: # 质量得分低， 平均质量得分小于6.5，小于5分的词大于40%
log.info('camp_id=%s adg_id=%s avg=%s rate=%s' % (camp.campaign_id, adg.adgroup_id, avg, rate))
print '质量得分低， 平均质量得分小于6.5，小于5分的词大于40%'
if adg_rpt_data.impressions3 > 0 and adg_rpt_data.click3 == 0: # 无点击， 连续3天有展现，点击为零
log.info('camp_id=%s adg_id=%s qr.impr=%s qr.click=%s' % (camp.campaign_id, adg.adgroup_id, adg_rpt_data.impressions3, adg_rpt_data.click3))
print '无点击， 连续3天有展现，点击为零'
if cat_click and example_cat_std_click and example_cat_click: # 点击少， 7日均点击少于 max(10,取某个行业点击做为参考值)
expression = example_cat_std_click * cat_click / example_cat_click
if avg_click_7_day < max(10, expression):
log.info('camp_id=%s adg_id=%s qr.click=%s cat.click=%s example_cat_std_click=%s example_cat_click=%s expression=%s' % (camp.campaign_id, adg.adgroup_id, avg_click_7_day, cat_click, example_cat_std_click, example_cat_click, expression))
print '点击少， 7日均点击少于 max(10,取某个行业点击做为参考值)'
elif item and item.price and cat_avg_ppc and cat_avg_conv and result and roi and ppc: # PPC高, 高于市场均价的1.2倍，大于 min（客单价＊行业转化率/roi, 每个 关键词点击量＊行业ppc 的和/所有点击, 日限额/50）
if ppc > cat_avg_ppc * 1.2 and min(item.price * cat_avg_conv / roi, result, camp.budget / 50):
log.info('camp_id=%s adg_id=%s ppc=%s roi=%s cat_avg_ppc=%s cat_avg_conv=%s budget=%s' % (camp.campaign_id, adg.adgroup_id, ppc, roi, cat_avg_ppc, cat_avg_conv, local_camp.budget))
print 'PPC高, 高于市场均价的1.2倍，大于 min（客单价＊行业转化率/roi, 每个 关键词点击量＊行业ppc 的和/所有点击, 日限额/50）'
elif cat_avg_ctr and ctr < cat_avg_ctr * 0.7: # 点击率低, 点击率低于市场点击率的70%
log.info('camp_id=%s adg_id=%s ctr=%s cat.avg_ctr=%s' % (camp.campaign_id, adg.adgroup_id, ctr, cat_avg_ctr))
print '点击率低, 点击率低于市场点击率的70%'
elif cat_avg_conv and conv < cat_avg_conv * 1.0: # 点击转化率低, 点击转化率低于市场点击率的100%
log.info('camp_id=%s adg_id=%s qr.conv=%s cat.avg_conv=%s' % (camp.campaign_id, adg.adgroup_id, conv, cat_avg_conv))
print '点击转化率低, 点击转化率低于市场点击率的100%'
def get_adgroup_list(strategy_name, date):
time1 = datetime(date.year, date.month, date.day, 0, 0, 0)
time2 = datetime(date.year, date.month, date.day, 23, 59, 59)
optrec_cur = optrec_coll.find({'strategy':strategy_name,
'create_time':{'$gte':time1},
'create_time':{'$lte':time2},
})
adgroup_id_list = [optrec['adgroup_id'] for optrec in optrec_cur]
adgroup_list = adg_coll.find({'_id':{'$in':adgroup_id_list}})
temp_list = []
for adgroup in adgroup_list:
temp_list.append(adgroup)
if len(temp_list) >= 4000:
return temp_list # trans_batch_dict_2document(src_dict_list = temp_list, class_object = Adgroup) or []
return temp_list # trans_batch_dict_2document(src_dict_list = temp_list, class_object = Adgroup) or []
def get_shop_keyword_list(shop_id):
try:
user = User.objects.get(shop_id = shop_id)
shop_type = user.shop_type
except User.DoesNotExist:
shop_type = "unknow"
shop_kw_list = []
adg_cursor = adg_coll.find({'shop_id': shop_id}, {'_id': 1, 'category_ids': 1})
adg_dict = {adg['_id']: adg['category_ids'].split(' ')[0] for adg in adg_cursor }
kw_cursor = kw_coll.find({'shop_id': shop_id}, {'word': 1, 'adgroup_id': 1, 'audit_status': 1})
for kw in kw_cursor:
cat_id = adg_dict.get(kw['adgroup_id'], '0') # 类目未知的case
is_illegal = kw['audit_status'] == 'audit_reject' and True or False
shop_kw_list.append({'category': cat_id, 'keyword': kw['word'], 'shop_type': shop_type, 'is_illegal': is_illegal})
return shop_kw_list
def add_all_recommand_words(cls):
word_list, count = [], 0
for adg in adg_coll.find({'has_push': {
'$in': [None, False]
}}, {'shop_id': 1},
timeout=False):
adg_coll.update({'_id': adg['_id']}, {'$set': {'has_push': True}})
try:
word_list.extend([
kw['word'] for kw in get_tb_recommend_keywords(
adg['shop_id'], adg['_id'])
])
except Exception, e:
log.error('can not get tapi and the error is =%s' % e)
pass
if len(word_list) >= 10000:
log.info('now get recommand words index is = %s' % count)
KeywordInfo.insert_new_word_list(word_list)
word_list = []
count += 1
def report_download(cls, shop_id, tapi, token, time_scope):
"""通过遍历广告组下载所有创意报表"""
init_start_time = datetime.datetime.today() - datetime.timedelta(
days=cls.Report.INIT_DAYS)
adg_tuple_list = [(adg['_id'], adg['campaign_id'],
adg.get('crtrpt_sync_time', init_start_time))
for adg in adg_coll.find({'shop_id': shop_id}, {
'_id': 1,
'campaign_id': 1,
'crtrpt_sync_time': 1
})]
result, reason = cls.download_crtrpt_byadgs(
shop_id=shop_id,
tapi=tapi,
token=token,
adg_tuple_list=adg_tuple_list)
if result:
log.info('download creative rpt OK, shop_id = %s' % (shop_id))
return 'OK'
else:
log.error('download creative rpt FAILED, shop_id = %s, e = %s' %
(shop_id, reason))
return 'FAILED'
for camp in temp_camp_list:
csv_data_list_1 = []
csv_data_list_2 = []
csv_data_list_3 = []
csv_data_list_4 = []
csv_data_list_5 = []
csv_data_list_6 = []
csv_data_list_7 = []
local_adg_list = Adgroup.objects.filter(online_status = 'online', shop_id = camp.shop_id, campaign_id = camp.campaign_id).order_by('adgroup_id') # 查询所有开启的推广组
adgroup_id_list = []
item_id_list = []
for adg in local_adg_list:
adgroup_id_list.append(adg.adgroup_id)
item_id_list.append(adg.item_id)
adg_rpt_dict = {adg['_id']:AdgroupHelper(**adg) for adg in adg_coll.find({'online_status': 'online', '_id': {'$in': adgroup_id_list}})}
item_dict = {item.item_id:item for item in Item.objects.filter(item_id__in = item_id_list)}
for adg in local_adg_list:
adg_rpt_data = None
item = None
if adg.adgroup_id in adg_rpt_dict.keys():
adg_rpt_data = adg_rpt_dict[adg.adgroup_id]
if adg.item_id in item_dict.keys():
item = item_dict[adg.item_id]
if not adg_rpt_data:
continue;
cat_data = adg.cat_data
kw_list = Keyword.objects.only('word').filter(adgroup_id = adg.adgroup_id)
kw_count = len(kw_list)
avg = get_avg_qscore(kw_list, adg.adgroup_id)
rate = get_qscore_rate(kw_list, adg.adgroup_id)
def adgroup_cost_data(request, dajax):
'''获取有花费的宝贝'''
shop_id = int(request.user.shop_id)
last_day = int(request.POST.get('last_day', 3))
page = int(request.POST.get('page', 1))
page_count = int(request.POST.get('page_count', 20))
rpt_dict = Adgroup.Report.get_summed_rpt(query_dict={
'shop_id': shop_id,
'cost': {
'$gt': 0
}
},
rpt_days=last_day)
adg_cur = adg_coll.find(
{
'shop_id': shop_id,
'mnt_type': {
'$in': [0, None]
}
}, {
'item_id': 1,
'campaign_id': 1
})
adg_list = []
for adg in adg_cur:
rpt = rpt_dict.get(adg['_id'], None)
if rpt:
adg['rpt'] = rpt
adg_list.append(adg)
adg_list.sort(key=lambda k: k['rpt'].cost, reverse=True)
total_count = len(adg_list)
adg_list = adg_list[(page - 1) * page_count:page * page_count]
json_adgroup_list = []
if adg_list:
adg_id_list, camp_id_list, item_id_list, camp_dict, item_dict, crt_dict = [], [], [], {}, {}, {}
for adg in adg_list: # 获取其他查询所必要的条件
adg_id_list.append(adg['_id'])
if not adg['campaign_id'] in camp_id_list:
camp_id_list.append(adg['campaign_id'])
if not adg['item_id'] in item_id_list:
item_id_list.append(adg['item_id'])
camp_list = Campaign.objects.only('title').filter(
shop_id=shop_id, campaign_id__in=camp_id_list)
item_list = Item.objects.only('title', 'price', 'pic_url').filter(
shop_id=shop_id, item_id__in=item_id_list)
create_list = Creative.objects.only('title', 'adgroup_id').filter(
shop_id=shop_id, adgroup_id__in=adg_id_list)
# 获取计划名称
camp_dict = {camp.campaign_id: camp.title for camp in camp_list}
# 获取宝贝标题，价格，图片路径
item_dict = {
item.item_id: {
'title': item.title,
'price': item.price,
'pic_url': item.pic_url
}
for item in item_list
}
for crt in create_list:
adg_id = crt['adgroup_id']
if crt_dict.has_key(adg_id):
crt_dict[adg_id].append(crt['title'])
else:
crt_dict[adg_id] = [crt['title']]
for adg in adg_list: # 附加item，campaign
adg_id, item_id, camp_id, adg_rpt = adg['_id'], adg[
'item_id'], adg['campaign_id'], adg['rpt']
creative_title_1, creative_title_2 = '', ''
if crt_dict.has_key(adg_id):
creative_title_1 = crt_dict[adg_id][0]
if len(crt_dict[adg_id]) == 2:
creative_title_2 = crt_dict[adg_id][1]
if not item_dict.get(item_id):
item_dict[item_id] = {
'title': '该宝贝可能不存在或者下架，请尝试同步数据',
'price': 0,
'pic_url': '/site_media/jl/img/no_photo'
}
json_adgroup_list.append({
'adgroup_id':
int(adg_id),
'campaign_id':
camp_id,
'campaign_title':
camp_dict[camp_id],
'item_id':
item_id,
'item_title':
item_dict[item_id]['title'],
# 'item_price':format(item_dict[item_id]['price'] / 100.0, '.2f'),
'item_pic_url':
item_dict[item_id]['pic_url'],
'creative_title_1':
creative_title_1,
'creative_title_2':
creative_title_2,
'total_cost':
format(adg_rpt.cost / 100.0, '.2f'),
'impr':
adg_rpt.impressions,
'click':
adg_rpt.click,
'click_rate':
format(adg_rpt.ctr, '.2f'),
'total_pay':
format(adg_rpt.pay / 100.0, '.2f'),
'paycount':
adg_rpt.paycount,
'conv':
format(adg_rpt.conv, '.2f')
})
result = {
'record_count': total_count,
'page': page,
'record': json_adgroup_list
}
dajax.script("PTQN.adgroup_cost.call_back(%s)" % (json.dumps(result)))
return dajax
