def query_keywords_rtclick(request, dajax):
shop_id = int(request.user.shop_id)
adg_id = int(request.POST.get("adg_id", 0))
adgroup, adg_info, result_data = None, {}, []
try:
adgroup = Adgroup.objects.get(adgroup_id=adg_id)
except:
pass
if adgroup:
kw_dict = {kw.keyword_id : kw for kw in Keyword.objects.filter(shop_id = shop_id, \
adgroup_id = adg_id)}
kw_rt_infos = get_hclick_kwrtrpt_byadgid(adgroup.shop_id, adgroup.campaign_id, \
adgroup.adgroup_id)
adg_info = {
'item_title': adgroup.item.title,
'camp_title': adgroup.campaign.title,
}
for kw_id, kw in kw_rt_infos.items():
kw_obj = kw_dict.get(kw_id, None)
if kw_obj:
temp = {
"kw_id": kw_id,
"camp_id": kw_obj.campaign_id,
"adg_id": kw_obj.adgroup_id,
"kw_name": kw_obj.word,
"kw_scope": kw_obj.match_scope,
"kw_price": round(kw_obj.max_price / 100.0, 2),
"kw_rt_impr": kw.impressions,
"kw_rt_cost": round(kw.cost / 100.0, 2),
"kw_rt_click": kw.click,
"kw_rt_pay_count": kw.paycount,
'item_pic_url': adgroup.item.pic_url,
}
result_data.append(temp)
result_data.sort(key=lambda obj:
(obj['kw_rt_click'], obj['kw_rt_impr']),
reverse=True)
result_data = result_data[:100] # top 100
func_name = 'query_keywords_rtclick'
func_desc = '获取某一宝贝关键词实时流量 -（宝贝关键词流量）'
args = json.dumps({'shop_id': shop_id, 'adgroup_id': adg_id})
result = len(result_data)
TempMonitor.generetor_record(shop_id, func_name, func_desc, args, result)
dajax.script("PTQN.kw_monitor.keyword_rtrpt_callback(%s,%s)" %
(json.dumps(result_data), json.dumps(adg_info)))
return dajax
def word_order(request, dajax):
'''获取关键词当前排名'''
from apps.engine.models import KeywordLocker
ip = get_ip_for_rank(request)
keyword_id = int(request.POST['keyword_id'])
adgroup_id = int(request.POST['adgroup_id'])
item_id = int(request.POST['item_id'])
kw_list = list(
Keyword.objects.filter(shop_id=int(request.user.shop_id),
adgroup_id=adgroup_id,
keyword_id=keyword_id))
if not kw_list:
# dajax.script('alert("该宝贝下无关键词，请点击“同步下载”菜单并检查是否有关键词，然后重试");')# TODO wuhuaqiao 2014-02-25
return dajax
# 批量查询关键词排名
KeywordLocker.get_item_kws_current_order_list(user=request.user,
item_id=item_id,
kw_list=kw_list,
ip=ip)
keyword = kw_list[0]
show_str = keyword.current_order
if keyword.current_order == 0:
show_str = '100+'
elif keyword.current_order >= 201:
show_str = '200+'
result = {'order': show_str, 'keyword_id': keyword_id}
dajax.script("PTQN.keyword_manage.call_back_order(%s)" %
(json.dumps(result)))
return dajax
def creative_optimization(request,
adgroup_id,
template="creative_optimization.html"):
# if request.user.shop_type == "C": # TODO zhongjinfeng 当B点的API搞定后全部切换回新版创意优化
# return HttpResponseRedirect(reverse("image_optimoze", kwargs = {'adgroup_id': adgroup_id}))
try:
shop_id = request.user.shop_id
adgroup = Adgroup.objects.exclude('rpt_list').get(
shop_id=shop_id, adgroup_id=adgroup_id)
adgroup.get_creative_rpt()
creatives = Creative.objects.filter(
shop_id=shop_id, adgroup_id=adgroup_id).bind_data(rpt_days=7)
for creative in creatives:
creative.rpt_days = 7
category_list, series_cfg_list = get_trend_chart_data(
data_type=3, rpt_list=creative.snap_list)
creative.category_list = category_list
creative.series_cfg_list = json.dumps(series_cfg_list)
except DoesNotExist:
return render_to_error(request, '该宝贝已经被删除，请返回页面重新操作')
# if adgroup.mnt_type:
# return render_to_error(request, '该宝贝已经由系统自动托管，请选择其他宝贝')
return render_to_response(template, {
'adg': adgroup,
'creatives': creatives
},
context_instance=RequestContext(request))
def upload_item_img(request):
"""上传商品主图"""
from apilib.binder import FileItem
error = ""
item_id = request.POST.get('item_id', None)
callback = request.POST.get('callback', None)
shop_id = int(request.user.shop_id)
tapi = tapi = get_tapi(shop_id=shop_id)
if request.method == 'POST':
file = request.FILES.get("item_img", None)
if file.size > 1024 * 1024 * 10:
error = "文件大小不能超过10M"
r = re.compile('^image/*')
if not r.match(file.content_type):
error = "只能上传图片，如:jpg,gif,png"
if error:
return HttpResponse('<script>require([]).%s(%s)</script>' %
(callback, json.dumps({'error': error})))
img_id, url = -1, ""
if item_id and shop_id and tapi:
try:
file_item = FileItem(file.name, file.read())
img_id, url, err = CustomCreative.item_img_upload(
tapi=tapi,
shop_id=shop_id,
num_iid=item_id,
image=file_item)
if err:
error = err
except Exception, e:
error = "上传图片到淘宝服务器错误"
else:
error = "参数不全"
return HttpResponse('<script>window.parent.%s(%s)</script>' %
(callback,
json.dumps({
'error': error,
'img_id': img_id,
'url': url
})))
def curwords_submit_4monitor(request, dajax):
'''提交关键词出价到直通车'''
from apps.web.utils import update_kws_8shopid
shop_id = int(request.user.shop_id)
kw_list = json.loads(request.POST.get('data', []))
updated_id_list, _, _, fail_update_id_list = update_kws_8shopid(
shop_id=shop_id, kw_list=kw_list)
result_data = {'success': updated_id_list, 'fall': fail_update_id_list}
func_name = 'curwords_submit_4monitor'
func_desc = '获取某一宝贝关键词实时流量 -（宝贝关键词流量）'
args = json.dumps(kw_list)
result = json.dumps(result_data)
TempMonitor.generetor_record(shop_id, func_name, func_desc, args, result)
dajax.script("PTQN.kw_monitor.kw_submit_callback(%s)" %
(json.dumps(result_data)))
return dajax
def mnt_campaign(request, dajax):
shop_id = int(request.user.shop_id)
campaign_id = int(request.POST['campaign_id'])
rpt_days = int(request.POST.get('rpt_days', 1))
try:
mnt_camp = MntCampaign.objects.get(shop_id=shop_id,
campaign_id=int(campaign_id))
if not mnt_camp.optimize_time:
mnt_camp.optimize_time = '尚未优化'
else:
mnt_camp.optimize_time = time_humanize(mnt_camp.optimize_time)
is_active = 1
if mnt_camp.quick_optime and time_is_someday(mnt_camp.quick_optime):
is_active = 0
campaign = Campaign.objects.get(shop_id=shop_id,
campaign_id=campaign_id)
sum_rpt = campaign.get_summed_rpt(rpt_days=rpt_days)
json_dict = {
'total_cost': fen2yuan(sum_rpt.cost),
'imp': sum_rpt.impressions,
'click': sum_rpt.click,
'ctr': '%.2f' % sum_rpt.ctr,
'cpc': fen2yuan(sum_rpt.cpc),
'total_pay': fen2yuan(sum_rpt.pay),
'roi': '%.2f' % sum_rpt.roi,
'conv': '%.2f' % sum_rpt.conv,
'paycount': sum_rpt.paycount
}
max_price = 0
if hasattr(mnt_camp, 'max_price'):
max_price = format(mnt_camp.max_price / 100.0, '.2f')
result = {
'set': {
'campaign_id': campaign_id,
'title': campaign.title,
'optimize_time': mnt_camp.optimize_time,
'max_price': max_price,
'budget': format(campaign.budget / 100.0, '.0f'),
'is_active': is_active,
'mnt_status': mnt_camp.mnt_status,
'mnt_type': mnt_camp.mnt_type,
},
'rpt': json_dict,
}
dajax.script("PTQN.mnt.mnt_campaign_back(%s)" % json.dumps(result))
except Exception, e:
log.error('missing args or campaign not exist, shop_id = %s, e = %s' %
(shop_id, e))
if 'query does not exist' in str(e): # 删除缓存
from apps.common.cachekey import CacheKey
CacheAdpter.delete(CacheKey.WEB_MNT_MENU % shop_id, 'web')
dajax.script('PTQN.alert("亲，请刷新页面重新操作！");')
def query_hclick_keywords(request, dajax):
"""查询有点击关键词"""
shop_id = int(request.user.shop_id)
kw_list = get_hclick_kwrtrpt_byshopid(shop_id)
kw_id_list = []
adg_id_set = set()
for kw in kw_list:
kw_id = int(kw.kw_id)
adg_id = int(kw.adgroup_id)
kw_id_list.append(kw_id)
adg_id_set.add(adg_id)
adg_id_list = list(adg_id_set)
kw_dict = {
kw.keyword_id: kw
for kw in Keyword.objects.filter(keyword_id__in=kw_id_list)
}
adg_dict = {
adg.adgroup_id: adg
for adg in Adgroup.objects.filter(adgroup_id__in=adg_id_list)
}
items_id_list = [adg.item_id for adg in adg_dict.values()]
item_dict = {
item.item_id: item
for item in Item.objects.filter(item_id__in=items_id_list)
}
result_data = []
for kw in kw_list:
kw_id = int(kw.kw_id)
adg_id = int(kw.adgroup_id)
kw_obj = kw_dict.get(kw_id, None)
adg_obj = adg_dict.get(adg_id, None)
if kw_obj and adg_obj:
item_obj = item_dict.get(adg_obj.item_id, None)
if item_obj:
temp = {
"kw_id": kw_id,
"camp_id": kw.campaign_id,
"adg_id": kw.adgroup_id,
"kw_name": kw_obj.word,
"kw_scope": kw_obj.match_scope,
"kw_price": round(kw_obj.max_price / 100.0, 2),
"kw_rt_cost": round(kw.cost / 100.0, 2),
"kw_rt_click": kw.click,
"kw_rt_pay_count": kw.paycount,
'item_pic_url': item_obj.pic_url,
'item_title': item_obj.title,
}
result_data.append(temp)
dajax.script("PTQN.kw_monitor.call_back(%s)" % (json.dumps(result_data)))
return dajax
def get_keywords_rankingforecast(request, dajax):
'''预测排名'''
kw_id_list = request.POST.getlist('kw_id_list[]')
tapi = get_tapi(request.user)
shop_id = int(request.user.shop_id)
forecast_data = {}
for kw_id in kw_id_list:
prices = Keyword.get_keyword_rankingforecast(tapi, shop_id, int(kw_id))
dajax.script('PTQN.keyword_manage.call_back_forecast(%s, %s)' %
(kw_id, json.dumps(prices)))
return dajax
def curwords_submit(request, dajax):
'''提交关键词出价到直通车'''
from apps.web.utils import update_kws_8shopid
shop_id = int(request.user.shop_id)
kw_list = json.loads(request.POST.get('data', []))
updated_id_list, _, _, fail_update_id_list = update_kws_8shopid(
shop_id=shop_id, kw_list=kw_list)
result = {'success': updated_id_list, 'fall': fail_update_id_list}
dajax.script("PTQN.keyword_manage.kw_submit_callback(%s)" %
(json.dumps(result)))
return dajax
def get_account_chart(request, dajax):
from apps.web.utils import get_trend_chart_data
shop_id = int(request.user.shop_id)
snap_dict = Account.Report.get_snap_list({'shop_id': shop_id}, rpt_days=7)
category_list, series_cfg_list = get_trend_chart_data(
data_type=5, rpt_list=snap_dict.get(shop_id, []))
series_list = [{
'name': i['name'],
'data': i['value_list'],
'color': i['color']
} for i in series_cfg_list]
result = {'x': category_list, 'series': series_list}
dajax.script("PTQN.account.chart_call_back(%s)" % (json.dumps(result)))
return dajax
def query_adgroups_rtclick(request, dajax):
shop_id = int(request.user.shop_id)
adg_rt_infos = get_hclick_adgrtrpt_byshopid(shop_id)
adg_id_list = adg_rt_infos.keys()
adg_dict = {adg.adgroup_id:adg for adg in Adgroup.objects.\
filter(shop_id = shop_id, adgroup_id__in = adg_id_list)}
items_id_list = [adg.item_id for adg in adg_dict.values()]
item_dict = {
item.item_id: item
for item in Item.objects.filter(item_id__in=items_id_list)
}
result_data = []
for adg_id, adg in adg_rt_infos.items():
adg_obj = adg_dict.get(adg_id, None)
if adg_obj:
item_obj = item_dict.get(adg_obj.item_id, None)
if item_obj:
temp = {
"adg_id": adg_id,
"camp_id": getattr(adg, 'campaign_id', None),
"adg_rt_click": getattr(adg, 'click', None),
'item_pic_url': item_obj.pic_url,
}
result_data.append(temp)
result_data.sort(key=lambda obj: obj['adg_rt_click'], reverse=True)
func_name = 'query_adgroups_rtclick'
func_desc = '获取宝贝实时流量-（实时监控首页）'
args = json.dumps({'shop_id': shop_id})
result = len(result_data)
TempMonitor.generetor_record(shop_id, func_name, func_desc, args, result)
dajax.script("PTQN.kw_monitor.adgroup_rtrpt_callback(%s)" %
(json.dumps(result_data)))
return dajax
def get_grammer_dict(request = None):
"""语法字典，通过版本号推送给客户端"""
VALIDATE_DICT = {'select_adgroup':{'download_kwrpt':{},
'optimize_keywords':{'instrcn_list':('str_list',)},
'add_keywords':{'min_num':('int', 140), 'conf_name':('str', 'auto_change')},
'sync_qscore':{},
'modify_out_limit_price':{},
'init_new_adgroups':{}},
'select_account':{},
'select_campaign':{},
'select_creative':{},
'select_keyword':{},
}
return json.dumps(VALIDATE_DICT)
def rob_record(request):
"""获取抢排名记录"""
errMsg, data = '', {}
keyword_id = int(request.POST['keyword_id'])
data = MessageChannel.get_history([keyword_id])
result_data = {}
for k, record_list in data.iteritems():
temp_list = []
for r_str in record_list:
r_dict = json.loads(r_str)
try:
r_dict['exp_rank_range'][0] = Keyword.RANK_START_DESC_MAP[
r_dict['platform']][str(r_dict['exp_rank_range'][0])]
r_dict['exp_rank_range'][1] = Keyword.RANK_END_DESC_MAP[
r_dict['platform']][str(r_dict['exp_rank_range'][1])]
except Exception, e:
r_dict['exp_rank_range'] = ['', '']
log.error('kw_id=%s, e=%s' % (keyword_id, e))
temp_list.append(json.dumps(r_dict))
result_data.update({k: temp_list})
def account_data(request, dajax):
'''获取账户关键词和趋势图数据'''
shop_id = int(request.user.shop_id)
last_day = int(request.POST.get('last_day', 7))
account = Account.objects.get(shop_id=shop_id)
rpt_sum = account.get_summed_rpt(rpt_days=last_day)
account_table = {
'total_cost': '%.2f' % (rpt_sum.cost / 100.0),
'click': rpt_sum.click,
'ctr': '%.2f' % rpt_sum.ctr,
'cpc': '%.2f' % (rpt_sum.cpc / 100.0),
'total_pay': '%.2f' % (rpt_sum.pay / 100.0),
'paycount': rpt_sum.paycount,
'roi': '%.2f' % rpt_sum.roi,
'conv': '%.2f' % rpt_sum.conv,
'balance': account.balance
}
result = {'account_table': account_table, 'common_message': []}
dajax.script("PTQN.account.call_back(%s)" % (json.dumps(result)))
return dajax
def forecast_order_list(request, dajax):
'''预估排名'''
kw_id = request.POST.get('keyword_id')
tapi = get_tapi(request.user)
rank_data = Keyword.rank_1_100(tapi=tapi, keyword_id=kw_id)
order_dict, order_list = {}, []
for rank, data in rank_data.items():
page_order = get_page_value_by_order(rank)
data['page'] = page_order
if not order_dict.has_key(page_order):
order_dict[page_order] = data
else:
if order_dict[page_order]['price'] > data['price']:
order_dict[page_order] = data
order_list = order_dict.values()
order_list.sort(lambda x, y: cmp(x['rank'], y['rank']))
result = {"kw_id": kw_id, "result": order_list}
dajax.script("PTQN.keyword_manage.call_back_forecast(%s)" %
(json.dumps(result)))
return dajax
def mnt_adg(request, dajax):
shop_id = int(request.user.shop_id)
campaign_id = int(request.POST['campaign_id'])
rpt_days = int(request.POST.get('rpt_days', 1))
page = int(request.POST.get('page', 1))
page_count = int(request.POST.get('page_count', 20))
try:
from apps.mnt.utils import get_adgroup_4campaign
adg_list, mnt_num = get_adgroup_4campaign(shop_id=shop_id,
campaign_id=campaign_id,
rpt_days=rpt_days)
result = {
'record_count': len(adg_list),
'page': page,
'record': adg_list[(page - 1) * page_count:page * page_count]
}
dajax.script("PTQN.mnt.mnt_adg_back(%s)" % (json.dumps(result)))
except Exception, e:
log.error(
'missing args or campaign not exist, campaign_id = %s, e = %s' %
(request.POST['campaign_id'], e))
dajax.script('PTQN.alert("亲，请刷新页面重新操作！");')
def get_statictics_category_info():
key = CacheKey.CRM_CAT_ADG_STATISTICS
cat_data = crm_cache.get(key)
if not cat_data:
crm_cache.delete(CacheKey.CRM_CAT_ADG_STATISTICS_LOCK)
lock_flag = crm_cache.get(CacheKey.CRM_CAT_ADG_STATISTICS_LOCK)
if lock_flag:
return {}
lock_flag = crm_cache.set(CacheKey.CRM_CAT_ADG_STATISTICS_LOCK, True,
10 * 60 * 60)
aggr_pipeline = [
{
'$group': {
'_id': {
'category_ids': '$category_ids'
},
'adgroup_total': {
'$sum': 1
}
}
},
# 暂过滤掉 < 5000,日后将会扩展
# {
# '$match':{
# 'adgroup_total':{
# "$gte":5000
# }
# }
# },
{
'$project': {
'_id': 0,
'cat_path': "$_id.category_ids",
'total': '$adgroup_total'
}
},
{
'$sort': {
'cat_path': 1,
'total': -1
}
}
]
cat_data = {}
try:
result = adg_coll.aggregate(aggr_pipeline)['result']
except Exception, e:
log.error('aggregate adgroup by category error, e=%s' % e)
return cat_data
cat_mapping = {}
cat_id_set = set()
for temp in result:
total = temp['total']
if temp.has_key('cat_path'):
category_ids = str(temp['cat_path']).split()
for index in xrange(len(category_ids)):
cat = '>'.join(category_ids[:index + 1])
if cat and cat != 'None':
if not cat_mapping.has_key(cat):
cat_mapping[cat] = 0
cat_id_set.add(int(category_ids[index]))
cat_mapping[cat] += total
else:
# 理论上应该不存在这个问题
pass
cat_name_mapping = {
cat['_id']: cat['cat_name']
for cat in cat_coll.find({'_id': {
"$in": list(cat_id_set)
}}, {'cat_name': 1})
}
for cat_all_path, total in cat_mapping.items():
cat_id_list = cat_all_path.split('>')
# 此处需要进行ID与名称之间转换
cat_all_name = []
for cat_id in cat_id_list:
cat_name = cat_name_mapping.get(int(cat_id), '')
if cat_name:
cat_all_name.append(cat_name)
else:
# 理论应不会出现该问题
log.error(
'error : it should not happen, the program is wrong if it appear, cat_id=%s'
% (cat_id))
continue
if cat_id_list:
base_dict = {
'cat_id': cat_id_list[-1],
'cat_name': '>'.join(cat_all_name),
'adgroup_total': total
}
cat_data[int(cat_id_list[-1])] = base_dict
data = zlib.compress(json.dumps(cat_data), 5)
crm_cache.set(key, data, 10 * 24 * 60 * 60)
crm_cache.delete(CacheKey.CRM_CAT_ADG_STATISTICS_LOCK)
def agent_login_in(request):
user_id = int(request.POST['user_id'])
user = User.objects.get(id=user_id)
login_url = user.get_backend_url(user_type="agent")['web_url']
return HttpResponse(json.dumps({'login_url': login_url}))
def route_ajax(request):
'''ajax路由函数，返回数据务必返回字典的格式'''
function_name = request.POST.get('function', '')
call_back = request.GET.get('callback')
try:
if function_name and globals().get(function_name, ''):
data = globals()[function_name](request=request)
else:
log.exception("route_ajax: function_name Does not exist")
data = {'error': 'function_name Does not exist'}
except Exception, e:
log.exception("route_ajax error, e=%s ,request_data=%s" %
(e, request.POST))
return HttpResponse('%s(%s)' % (call_back, json.dumps(data)))
def select_keyword_order(request):
def get_title(html, shop_type):
tt = html.find('title')[-1].text.lower()
split_index = tt.rfind('-')
title = tt[:split_index]
if u'天猫' in tt or 'tmall' in tt:
st = shop_type[u'tmall.com天猫']
elif u'淘宝网' in tt:
st = shop_type[u'淘宝网']
else:
st = shop_type[tt[split_index + 1:]]
return title, st
call_back = request.GET.get('callback')
try:
if function_name and globals().get(function_name, ''):
data = globals()[function_name](request=request)
else:
log.exception("route_ajax: function_name Does not exist")
data = {'error': 'function_name Does not exist'}
except Exception, e:
log.exception("route_ajax error, e=%s ,request_data=%s" %
(e, request.POST))
if 'AnonymousUser' in str(e):
data = {'errMsg': '会话已过期，请重新登录！'}
else:
data = {'errMsg': '未知错误，请联系顾问！'}
return HttpResponse('%s' % json.dumps(data))
def balance(request):
"""获取账户余额"""
errMsg = ""
balance = 0
try:
shop_id = int(request.user.shop_id)
account = Account.objects.get(shop_id=shop_id)
balance = account.balance
except DoesNotExist:
errMsg = "账户不存在"
log.error('get balance error Account does not exist')
return {'errMsg': errMsg, "balance": balance}
def route_ajax(request):
'''ajax路由函数，返回数据务必返回字典的格式'''
if not request.user.is_authenticated():
return {'errMsg':'您已经退出，请重新登录之后再试'}
function_name = request.POST.get('function', '')
call_back = request.GET.get('callback')
try:
if function_name and globals().get(function_name, ''):
data = globals()[function_name](request = request)
else:
log.exception("route_ajax: function_name Does not exist")
data = {'error': 'function_name Does not exist'}
except Exception, e:
log.exception("route_ajax error, e=%s ,request_data=%s" %
(e, request.POST))
return HttpResponse('%s(%s)' % (call_back, json.dumps(data)))
# 设置托管计划
def mnt_campaign_setter(request):
error_msg = None
shop_id = int(request.user.shop_id)
mnt_type = int(request.POST.get('mnt_type'))
campaign_id = int(request.POST['campaign_id'])
set_flag = int(request.POST['set_flag']) and True or False # 设置为托管计划或者终止托管计划
opter, opter_name = analysis_web_opter(request)
try:
warn_msg_dict = {}
if mnt_type not in [1, 2, 3, 4]:
raise Exception("wrong_mnt_type")
if set_flag:
mnt_rt = int(request.POST.get('mnt_rt', 0)) # 是否启用实时引擎
def compress_obj(obj):
"""压缩，先转json，再用bz2压缩，470K能压缩成20多K"""
temp_json = json.dumps(obj)
return bz2.compress(temp_json)
def mnt_campaign(request, campaign_id, template='mnt_campaign.html'):
shop_id = int(request.user.shop_id)
campaign_id = int(campaign_id)
mnt_list = []
mnt_campaign_dict = dict(
MntCampaign.objects.filter(shop_id=shop_id).values_list(
'campaign_id', 'mnt_type'))
campaign_list = list(Campaign.objects.filter(shop_id=shop_id))
mnt_desc_dict = dict(MNT_TYPE_CHOICES)
campaign = None
for camp in campaign_list:
camp.mnt_type = mnt_campaign_dict.get(camp.campaign_id, 0)
camp.mnt_name = mnt_desc_dict.get(camp.mnt_type, '').replace(
'托管', '') if camp.mnt_type else '手动'
mnt_list.append({
'campaign_id': camp.id,
'name': camp.title,
'mnt_type_name': camp.mnt_name
})
if camp.id == campaign_id:
campaign = camp
if campaign is None:
return render_to_error(request, "该计划不存在，请返回页面重新操作")
snap_list = campaign.get_snap_list(rpt_days=7)
start_time = None
mnt_days = 0
try:
mnt_camp = MntCampaign.objects.get(shop_id=shop_id,
campaign_id=campaign_id)
campaign.optimize_time = mnt_camp.optimize_time and time_humanize(
mnt_camp.optimize_time) or "0"
campaign.mnt_type = mnt_camp.mnt_type
campaign.max_num = mnt_camp.max_num
campaign.max_price = '%.2f' % (mnt_camp.max_price / 100.0)
campaign.mobile_max_price = '%.2f' % (mnt_camp.real_mobile_max_price /
100.0)
campaign.mnt_desc = mnt_camp.get_mnt_type_display()
campaign.is_active = mnt_camp.is_active
campaign.quick_optime = mnt_camp.quick_optime
campaign.mnt_bid_factor = mnt_camp.mnt_bid_factor
campaign.mnt_rt = mnt_camp.mnt_rt
start_time = datetime_2string(mnt_camp.start_time, '%Y年%m月%d日')
mnt_days = days_diff_interval(mnt_camp.start_time.date())
except DoesNotExist:
campaign.mnt_type = 0
campaign.max_num = 0
campaign.max_price = 0.00
campaign.mobile_max_price = 0.00
campaign.mnt_desc = "未托管计划"
campaign.is_active = False
campaign.quick_optime = datetime.datetime.now()
campaign.mnt_bid_factor = 50
campaign.mnt_rt = 0
is_smooth = campaign.is_smooth and 1 or 0
budget = '%.0f' % (campaign.budget / 100.0)
from apps.web.utils import get_trend_chart_data
category_list, series_cfg_list = get_trend_chart_data(data_type=2,
rpt_list=snap_list)
snap_list.reverse()
camp_dict = dict(
Campaign.objects.filter(shop_id=shop_id).values_list(
'campaign_id', 'title'))
mnt_opter, _ = analysis_web_opter(request)
return render_to_response(template, {
'camp': campaign,
'mnt_list': mnt_list,
'snap_list': snap_list,
'is_smooth': is_smooth,
'budget': budget,
'category_list': category_list,
'series_cfg_list': json.dumps(series_cfg_list),
'camp_dict': camp_dict,
'mnt_opter': mnt_opter,
'add_adgroup': campaign.mnt_type,
'start_time': start_time,
'mnt_days': mnt_days
},
context_instance=RequestContext(request))
shop_id = int(request.user.shop_id)
keyword_id = int(request.POST.get('keyword_id'))
adgroup_id = int(request.POST.get('adgroup_id'))
try:
Attention.change_attention_state(shop_id, adgroup_id, keyword_id,
False)
result = [keyword_id]
except Exception, e:
log.error('cancel attention error, shop_id=%s, keyword_id=%s, e=%s' %
(shop_id, keyword_id, e))
result = []
finally:
dajax.script("PTQN.keyword_manage.call_back_cancel_attention(%s)" %
(json.dumps(result)))
return dajax
shop_id = int(request.user.shop_id)
kw_list = json.loads(request.POST.get('data', []))
opter, opter_name = analysis_web_opter(request)
updated_id_list, _, _, fail_update_id_list = update_kws_8shopid(
shop_id=shop_id, kw_list=kw_list, opter=opter, opter_name=opter_name)
result = {'success': updated_id_list, 'fall': fail_update_id_list}
dajax.script("PTQN.keyword_manage.call_back_submit(%s)" %
(json.dumps(result)))
return dajax
def auto_set_attention_kw(request, dajax):
'''一键设置关键词'''
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
def keyword_manage_data(request, dajax):
'''获取重点关注的关键词列表'''
from apps.subway.download import Downloader
shop_id = int(request.user.shop_id)
page = int(request.POST.get('page', 1))
page_count = int(request.POST.get('page_count', 20))
json_kw_list = []
kw_list = Attention.get_attention_list(shop_id)
kw_id_list = [kw.keyword_id for kw in kw_list]
kw_rpt_dict = Keyword.Report.get_summed_rpt(
{
'shop_id': shop_id,
'keyword_id': {
'$in': kw_id_list
}
}, rpt_days=15)
for kw in kw_list:
kw.rpt = kw_rpt_dict.get(kw.keyword_id, Keyword.Report())
kw_list.sort(key=lambda kw: kw.rpt.cost, reverse=True)
adg_id_list, item_dict, camp_id_list, camp_dict = [], {}, [], {}
for kw in kw_list:
if kw.adgroup_id not in adg_id_list:
adg_id_list.append(kw.adgroup_id)
if kw.campaign_id not in camp_id_list:
camp_id_list.append(kw.campaign_id)
# 下载有展现的adgroup_id的关键词报表
dler_obj, _ = Downloader.objects.get_or_create(shop_id=shop_id)
dl_flag, _ = dler_obj.check_status_4rpt(klass=Keyword)
if dl_flag and dler_obj.tapi:
Keyword.download_kwrpt_bycond(shop_id=shop_id,
tapi=dler_obj.tapi,
token=dler_obj.token,
rpt_days=15,
cond='impressions',
adg_id_list=adg_id_list)
adg_list = Adgroup.objects.filter(shop_id=shop_id,
adgroup_id__in=adg_id_list)
camp_list = Campaign.objects.filter(shop_id=shop_id,
campaign_id__in=camp_id_list)
for adgroup in adg_list:
if adgroup.item:
item_dict[adgroup.adgroup_id] = {
'id': adgroup.item.item_id,
'title': adgroup.item.title,
'price': '%.2f' % (adgroup.item.price / 100.0),
'pic_url': adgroup.item.pic_url
}
else:
for kw in kw_list:
if kw.adgroup_id == adgroup.adgroup_id:
kw_list.remove(kw)
for camp in camp_list:
camp_dict[camp.campaign_id] = {'title': camp.title}
for kw in kw_list:
json_kw_list.append({
"keyword_id": kw.keyword_id,
"adgroup_id": kw.adgroup_id,
"campaign_id": kw.campaign_id,
"item_id": item_dict[kw.adgroup_id]['id'],
"item_pic_url": item_dict[kw.adgroup_id]['pic_url'],
# "item_price":item_dict[kw.adgroup_id]['price'],
# "item_title":item_dict[kw.adgroup_id]['title'],
"word": kw.word,
# "create_days":kw.create_days,
"max_price": format(kw.max_price / 100.0, '.2f'),
"qscore": kw.qscore,
"impressions": kw.rpt.impressions,
"click": kw.rpt.click,
"ctr": format(kw.rpt.ctr, '.2f'),
"cost": format(kw.rpt.cost / 100.0, '.2f'),
"cpc": format(kw.rpt.cpc / 100.0, '.2f'),
# "favcount":kw.rpt.favcount,
"paycount": kw.rpt.paycount,
"pay": format(kw.rpt.pay / 100.0, '.2f'),
"conv": format(kw.rpt.conv, '.2f'),
"roi": format(kw.rpt.roi, '.2f'),
"g_click": format_division(kw.g_click, 1, 1, '0'),
"g_cpc": format_division(kw.g_cpc, 100, 1),
# "g_ctr":format_division(kw.g_click , kw.g_pv),
# "g_competition":format_division(kw.g_competition , 1, 1, '0'),
# "g_pv":kw.g_pv,
"match_scope": kw.match_scope,
"is_focus": kw.is_focus and 1 or 0
})
result = {
'record_count': len(json_kw_list),
'page': page,
'record': json_kw_list[(page - 1) * page_count:page * page_count]
}
dajax.script("PTQN.keyword_manage.call_back(%s)" % (json.dumps(result)))
return dajax
def dispatch(request):
if request.method == 'GET':
req_data = request.GET
else:
req_data = request.POST
param_dict = {}
param_dict.update(request.REQUEST)
check_result = jl_check_sign_with_secret(param_dict, timeout=60 * 10)
if check_result == 'no_permission':
rst = {
"error_response": {
"code": 25,
"msg": "Invalid Signature",
"sub_code": "isv.invalid-permission",
"sub_msg": "have no permission"
}
}
json_data = json.dumps(rst)
return HttpResponse(json_data)
elif check_result == 'timeout':
rst = {
"error_response": {
"code": 43,
"msg": "Invalid Timestamp",
"sub_code": "isv.invalid-parameter",
"sub_msg": "timeout"
}
}
json_data = json.dumps(rst)
return HttpResponse(json_data)
else:
pass
if req_data.has_key('method') and req_data.has_key('app'):
app = req_data['app']
method = req_data['method']
if req_data.has_key('is_sync') and req_data['is_sync'] == 'False':
is_sync = False
else:
is_sync = True
else:
json_data = json.dumps({
"error_response": {
"code": 40,
"msg": "Missing Required Arguments",
"sub_code": "isv.missing-parameter",
"sub_msg": "wrong request APP.METHOD(GET or POST)"
}
})
return HttpResponse(json_data)
try:
api_function, args, varargs, varkw, defaults = get_api_function_info(
app, method)
kwargs = {}
# 根据函数定义的默认参数和request中的数据 组装**kwargs
if defaults: # 先填充默认参数
for i in range(len(defaults)):
kwargs[args[-1 - i]] = defaults[-1 - i]
for arg in args: # 再填充request数据中有的参数
if req_data.has_key(arg):
if req_data.has_key(arg + '__eval'):
kwargs[arg] = eval(req_data[arg])
else:
kwargs[arg] = req_data[arg]
kwargs['request'] = request # api函数，必须包含了request参数
# 检查是否有未赋值的参数：
missing_args = [arg for arg in args if arg not in kwargs.keys()]
if missing_args:
json_data = json.dumps({
"error_response": {
"code": 40,
"msg": "Missing Required Arguments",
"sub_code": "isv.missing-parameter",
"sub_msg":
"missing parameters (%s)" % (','.join(missing_args))
}
})
return HttpResponse(json_data)
if not is_sync:
nt = NewThread(api_function, **kwargs)
nt.start()
rst = {'%s_response' % (method): {'result': True}}
json_data = json.dumps(rst)
else:
rst = {'%s_response' % (method): api_function(**kwargs)}
json_data = json.dumps(rst)
except Exception, e:
rst = {
"error_response": {
"code": 15,
"msg": "Remote service error",
"sub_code": "isp.unknown-error",
"sub_msg": "call %s.api.%s raise e=%s" % (app, method, e)
}
}
log.error('api req_data=%s, rst=%s' % (req_data, rst))
json_data = json.dumps(rst)
