def mama_pay_deposit(customer_id, deposit_type, referrer, trade_id, oid=None):
# type: (int, int, int, int, Optional[text_type]) -> None
"""用户支付押金妈妈记录相关处理
"""
customer = get_customer_by_id(customer_id)
xlmm = customer.get_xiaolumm()
if not xlmm:
return
if deposit_type not in [1, 99, 188]:
return
if deposit_type == 1:
renew_days = XiaoluMama.TRIAL
if not xlmm.is_trialable():
return # 不可以试用
# create_potential_mama(xlmm, referrer) # 创建潜在妈妈记录
elif deposit_type == 99:
renew_days = XiaoluMama.HALF
elif deposit_type == 188:
renew_days = XiaoluMama.FULL
mama_charged = xlmm.chargemama() # 接管妈妈
sys_oa = get_systemoa_user()
if mama_charged:
log_action(sys_oa, xlmm, CHANGE, u'代理接管成功')
xlmm.update_renew_day(renew_days) # 修改下次续费时间
xlmm.deposit_pay() # 支付押金
log_action(sys_oa, xlmm, CHANGE, u'支付押金')
release_coupon_for_deposit(customer_id, deposit_type, trade_id=trade_id) # 发送押金优惠券给用户
update_potential_by_deposit(xlmm.id, renew_days, referrer_mama_id=referrer, oid=oid) # 更新潜在关系记录
signal_xiaolumama_register_success.send_robust(sender=XiaoluMama, xiaolumama=xlmm, renew=True) # 发送信号
def change_pwd_code(self, request):
"""忘记密码时获取验证码"""
mobile = request.data['vmobile']
already_exist = Customer.objects.filter(mobile=mobile).exclude(status=Customer.DELETE)
current_time = datetime.datetime.now()
last_send_time = current_time - datetime.timedelta(seconds=TIME_LIMIT)
if already_exist.count() == 0:
return Response({"result": "1"}) # 尚无用户或者手机未绑定
if mobile == "" or not re.match(PHONE_NUM_RE, mobile): # 进行正则判断
return Response({"result": "false"})
sysoa_user = get_systemoa_user()
reg = Register.objects.filter(vmobile=mobile)
if reg.count() == 0:
new_reg = Register(vmobile=mobile)
new_reg.verify_code = new_reg.genValidCode()
new_reg.verify_count = 0
new_reg.mobile_pass = True
new_reg.code_time = current_time
new_reg.save()
log_action(sysoa_user.id, new_reg, ADDITION, u'新建，忘记密码验证码')
task_register_code.delay(mobile, "2")
return Response({"result": "0"})
else:
reg_temp = reg[0]
if check_day_limit(reg_temp):
return Response({"result": "2"}) # 当日验证次数超过5
if reg_temp.code_time and reg_temp.code_time > last_send_time:
return Response({"result": "3"}) # 180s内已经发送过
reg_temp.verify_code = reg_temp.genValidCode()
reg_temp.code_time = current_time
reg_temp.save()
log_action(sysoa_user.id, reg_temp, CHANGE, u'修改，忘记密码验证码')
task_register_code.delay(mobile, "2")
return Response({"result": "0"})
def comfirm_get(out_sid, status): #根据物流状态自动确认收货
out_sid = str(out_sid)
confirm_psi_finish(out_sid=out_sid, status=status)
logging.warn("comfirm_get")
logger.warn({'action': "kdn", 'info': "start_comfirm_get:" + out_sid})
tradewuliu = TradeWuliu.objects.filter(out_sid=out_sid).order_by("-id")
confirm_get_by_content(out_sid, tradewuliu.first().content)
packageskuitem = PackageSkuItem.objects.filter(
out_sid=out_sid).values("oid")
logger.warn({
'action': "kdn",
'info': "oid_by_out_sid:" + json.dumps(list(packageskuitem))
})
if packageskuitem and int(status) == 3:
logger.warn({'action': "kdn", 'info': "exp_num:" + out_sid})
packageskuitem = [i['oid'] for i in packageskuitem]
so = SaleOrder.objects.filter(
oid__in=packageskuitem, status=SaleOrder.WAIT_BUYER_CONFIRM_GOODS)
if so:
for i in so:
logger.warn({
'action': "kdn",
'info': "change_get_goods:" + out_sid
})
i.confirm_sign_order()
from core.options import log_action, CHANGE, ADDITION, get_systemoa_user
sys_oa = get_systemoa_user()
log_action(sys_oa, i, CHANGE,
u'confirm_sign_order comfirm_get')
def task_update_trial_mama_full_member_by_condition(mama):
"""
检查该妈妈的推荐人是否是 试用用户
如果是 试用用户数
满足邀请三个188 或者
这里用续费天数 判断
"""
if True:
return
trial_mama = XiaoluMama.objects.filter(mobile=mama.referal_from,
status=XiaoluMama.EFFECT, # 自接管后 15天 变为冻结
last_renew_type=XiaoluMama.TRIAL).first() # 推荐人(试用用户并且是有效状态的)
if not trial_mama:
return
join_mamas = XiaoluMama.objects.filter(referal_from=trial_mama.mobile,
status=XiaoluMama.EFFECT,
last_renew_type=XiaoluMama.FULL, # 邀请的是188
agencylevel__gte=XiaoluMama.VIP_LEVEL,
charge_status=XiaoluMama.CHARGED) # 推荐人邀请的正式妈妈
if join_mamas.count() >= 3: # 满足条件
trial_mama.last_renew_type = XiaoluMama.HALF # 转正为半年的类型
trial_mama.renew_time = trial_mama.renew_time + datetime.timedelta(days=XiaoluMama.HALF)
trial_mama.save(update_fields=['last_renew_type', 'renew_time'])
sys_oa = get_systemoa_user()
log_action(sys_oa, trial_mama, CHANGE, u'满足转正条件,转为正式妈妈')
# 修改潜在小鹿妈妈列表中的 转正状态
potential = PotentialMama.objects.filter(potential_mama=trial_mama.id, is_full_member=False).first()
if potential:
potential.is_full_member = True
potential.save(update_fields=['is_full_member'])
log_action(sys_oa, potential, CHANGE, u'满足转正条件,转为正式妈妈')
def confirm_get_by_content(out_sid, content): #根据物流内容自动确认收货
out_sid = str(out_sid)
confirm_psi_finish(out_sid=out_sid, content=content)
logging.warn("confirm_get_by_content")
logger.warn({'action': "kdn", 'info': "confirm_get_by_content:" + out_sid})
if content.find("\u5df2\u7b7e\u6536") != -1 or content.find(
"\u59a5\u6295") != -1:
packageskuitem = PackageSkuItem.objects.filter(
out_sid=out_sid).values("oid")
if packageskuitem:
packageskuitem = [i['oid'] for i in packageskuitem]
so = SaleOrder.objects.filter(
oid__in=packageskuitem,
status=SaleOrder.WAIT_BUYER_CONFIRM_GOODS)
if so:
for i in so:
logger.warn({
'action': "kdn",
'info': "confirm_sign_order:" + out_sid
})
i.confirm_sign_order()
from core.options import log_action, CHANGE, ADDITION, get_systemoa_user
sys_oa = get_systemoa_user()
log_action(sys_oa, i, CHANGE,
u'confirm_sign_order confirm_get_by_content')
def confirm_get_by_state(out_sid, status):
out_sid = str(out_sid)
status = int(status)
if not out_sid or not status or status != 3:
return
psi = PackageSkuItem.objects.filter(out_sid=out_sid).first()
if psi:
logger.warn({
'action': "kd100",
'info': "confirm_psi_finish_kd100:" + str(out_sid)
})
pid = psi.package_order_pid
PackageOrder.objects.filter(pid=pid).update(
sys_status=PackageOrder.FINISHED_STATUS)
psi.set_status_finish()
packageskuitem = PackageSkuItem.objects.filter(
out_sid=out_sid).values("oid")
if packageskuitem:
packageskuitem = [i['oid'] for i in packageskuitem]
so = SaleOrder.objects.filter(
oid__in=packageskuitem, status=SaleOrder.WAIT_BUYER_CONFIRM_GOODS)
if so:
for i in so:
logger.warn({
'action': "kd100",
'info': "confirm_sign_order_kd100:" + str(out_sid)
})
i.confirm_sign_order()
from core.options import log_action, CHANGE, ADDITION, get_systemoa_user
sys_oa = get_systemoa_user()
log_action(sys_oa, i, CHANGE, u'confirm_sign_order_kd100')
def create(self, request, *args, **kwargs):
"""发送验证码时候新建register对象"""
mobile = request.data.get('vmobile')
current_time = datetime.datetime.now()
last_send_time = current_time - datetime.timedelta(seconds=TIME_LIMIT)
if not mobile or not re.match(PHONE_NUM_RE, mobile): # 进行正则判断
raise exceptions.APIException(u'手机号码格式不对')
ip = get_client_ip(request)
get_agent_src = self.get_agent_src(request)
logger.debug('register: %s, %s, %s' % (ip, mobile, get_agent_src))
if get_agent_src == 'windows':
import random
rnum = random.randint(1, 10)
if rnum % 2 == 1:
return Response({"result": "0", "code": 0, "info": "手机已注册"})
else:
return Response({"result": "OK", "code": 0, "info": "OK"})
customers = Customer.objects.filter(mobile=mobile).exclude(status=Customer.DELETE)
if customers.exists():
return Response({"result": "0", "code": 0, "info": "手机已注册"})
sysoa_user = get_systemoa_user()
reg = Register.objects.filter(vmobile=mobile)
if reg.count() > 0:
temp_reg = reg[0]
reg_pass = reg.filter(mobile_pass=True)
if reg_pass.count() > 0:
return Response({"result": "0", "code": 0, "info": "手机已注册"}) # 已经注册过
if check_day_limit(temp_reg):
return Response({"result": "2", "code": 2, "info": "当日验证次数超过5"}) # 当日验证次数超过5
if temp_reg.code_time and temp_reg.code_time > last_send_time:
return Response({"result": "1", "code": 1, "info": "180s内已经发送过"}) # 180s内已经发送过
else:
temp_reg.verify_code = temp_reg.genValidCode()
temp_reg.code_time = current_time
temp_reg.save()
log_action(sysoa_user.id, temp_reg, CHANGE, u'修改，注册手机验证码')
task_register_code.delay(mobile, "1")
return Response({"result": "OK", "code": 0, "info": "OK"})
else:
try:
new_reg = Register(vmobile=mobile)
new_reg.verify_code = new_reg.genValidCode()
new_reg.verify_count = 0
new_reg.code_time = current_time
new_reg.save()
except IntegrityError:
return Response({"result": "0", "code": 0, "info": "请勿重复点击"})
log_action(sysoa_user.id, new_reg, ADDITION, u'新建，注册手机验证码')
task_register_code.delay(mobile, "1")
return Response({"result": "OK", "code": 0, "info": "OK"})
def update_model_product_shelf_time(sender, instance, raw, *args, **kwargs):
from flashsale.pay.models import ModelProduct
if not instance.lock_status: # do not sync shelf time and schedule type if this instance not locked
return
action_user = get_systemoa_user()
sale_product_ids = instance.manage_schedule.values('sale_product_id')
is_topic = False if instance.schedule_type == SaleProductManage.SP_SALE else True
is_topic = False if instance.is_sale_show else is_topic
ModelProduct.update_schedule_manager_info(action_user, sale_product_ids,
instance.upshelf_time,
instance.offshelf_time, is_topic)
def check_xlmm_ordercarry(recent_days):
results = []
tt = datetime.datetime.now()
tf = tt - datetime.timedelta(days=recent_days)
from flashsale.pay.models.trade import SaleOrder, SaleTrade, Customer
queryset = SaleOrder.objects.filter(status__in=[
SaleOrder.WAIT_SELLER_SEND_GOODS, SaleOrder.WAIT_BUYER_CONFIRM_GOODS,
SaleOrder.TRADE_BUYER_SIGNED, SaleOrder.TRADE_FINISHED,
SaleOrder.TRADE_CLOSED, SaleOrder.TRADE_CLOSED_BY_SYS
],
created__gte=tf)
for order in queryset.iterator():
# 特卖订单有ordercarry或inderect mama 虚拟订单有
indirect_mama = False
from flashsale.xiaolumm.models import XiaoluMama
if order.sale_trade.order_type == SaleTrade.ELECTRONIC_GOODS_ORDER:
customer = Customer.objects.get(id=order.buyer_id)
to_mama = customer.get_xiaolumm()
if to_mama and to_mama.referal_from == XiaoluMama.INDIRECT:
indirect_mama = True
if order.sale_trade.order_type == SaleTrade.SALE_ORDER or indirect_mama:
order_carry_qs = OrderCarry.objects.filter(order_id=order.oid)
if not order_carry_qs:
from flashsale.xiaolumm.tasks import task_order_trigger
task_order_trigger(order)
order_carry_qs = OrderCarry.objects.filter(order_id=order.oid)
if order_carry_qs:
results.append(order.oid)
continue
status = OrderCarry.STAGING # unpaid
if order.need_send():
status = OrderCarry.ESTIMATE
elif order.is_confirmed():
status = OrderCarry.CONFIRM
elif order.is_canceled():
status = OrderCarry.CANCEL
update_fields = ['status', 'modified']
for order_carry in order_carry_qs:
if status != order_carry.status:
from core.options import log_action, CHANGE, get_systemoa_user
logmsg = 'status not equal to saleorder|status:%s->%s' % (
order_carry.status, status)
order_carry.status = status
order_carry.save(update_fields=update_fields)
sys_oa = get_systemoa_user()
log_action(sys_oa, order_carry, CHANGE, logmsg)
results.append(order.oid)
return results
def handle(self, *args, **options):
# task_fresh_elitemama_active_status()
now = datetime.datetime.now()
sys_oa = get_systemoa_user()
effect_elite_mms = XiaoluMama.objects.filter(
status=XiaoluMama.EFFECT,
last_renew_type=XiaoluMama.SCAN)
for emm in effect_elite_mms.iterator():
try:
emm.status = XiaoluMama.FROZEN
emm.save(update_fields=['status'])
log_action(sys_oa, emm, CHANGE, u'schedule task: renew timeout,chg to frozen')
except TypeError as e:
logger.error(u" FROZEN mama:%s, error info: %s" % (emm.id, e))
def change_user_pwd(self, request):
"""手机校验修改密码"""
mobile = request.data['username']
passwd1 = request.data['password1']
passwd2 = request.data['password2']
verify_code = request.data['valid_code']
current_time = datetime.datetime.now()
last_send_time = current_time - datetime.timedelta(seconds=TIME_LIMIT)
if not mobile or not passwd1 or not passwd2 or not verify_code or passwd2 != passwd1:
return Response({"result": "2"})
already_exist = Customer.objects.filter(mobile=mobile).exclude(status=Customer.DELETE)
if not already_exist.exists():
user = request.user
if not user or user.is_anonymous:
return Response({"result": "1"}) # 尚无用户或者手机未绑定
already_exist = Customer.objects.filter(user=user).exclude(status=Customer.DELETE)
customer = already_exist[0]
reg = Register.objects.filter(vmobile=mobile)
if reg.count() == 0:
return Response({"result": "3"}) # 未获取验证码
reg_temp = reg[0]
verify_code_server = reg_temp.verify_code
reg_temp.submit_count += 1 # 提交次数加一
reg_temp.save()
if reg_temp.code_time and reg_temp.code_time < last_send_time:
return Response({"result": "4"})
if verify_code_server != verify_code:
return Response({"result": "3"}) # 验证码不对
sysoa_user = get_systemoa_user()
try:
system_user = customer.user
system_user.set_password(passwd1)
system_user.save()
reg_temp.cus_uid = already_exist[0].id
reg_temp.save()
if self.is_login(request):
customer.mobile = mobile
customer.save()
log_action(sysoa_user.id, already_exist[0], CHANGE, u'忘记密码，修改成功')
log_action(sysoa_user.id, reg_temp, CHANGE, u'忘记密码，修改成功')
except:
return Response({"result": "5"})
return Response({"result": "0"})
def task_dinghuo_supplier():
"""将供应商名字写入订货表"""
since_time = datetime.date(2015, 9, 20)
all_dinghuo = OrderList.objects.filter(created__gt=since_time, supplier_shop="")
for one_dinghuo in all_dinghuo:
all_product = [detail.product_id for detail in one_dinghuo.order_list.all()]
supplier = ""
for one_product in all_product:
try:
a = Product.objects.get(id=one_product)
sale_product = SaleProduct.objects.get(id=a.sale_product)
supplier = sale_product.sale_supplier.supplier_name
break
except:
continue
if supplier != "":
one_dinghuo.supplier_shop = supplier
one_dinghuo.save()
log_action(get_systemoa_user().id, one_dinghuo, CHANGE, u'修改供应商')
def create(ibds, optimize_forecast_id, express_no, type):
now = datetime.datetime.now()
tmp = ['-->%s %s: 创建入仓单' % (now.strftime('%m月%d %H:%M'), "系统")]
from shopback.forecast.models.forecast import ForecastInbound
forecast = ForecastInbound.objects.get(
forecast_no=optimize_forecast_id)
supplier_id = forecast.supplier_id
orderlist_id = forecast.orderlist_id
inbound = InBound(supplier_id=supplier_id,
express_no=express_no,
forecast_inbound_id=forecast.id,
ware_by=forecast.ware_house,
ori_orderlist_id=orderlist_id,
memo='\n'.join(tmp),
creator=get_systemoa_user(),
type=type)
inbound.save()
for ibd in ibds:
ibd.inbound = inbound
ibd.save()
if inbound.type == InBound.AUTOMATIC:
inbound.allocate() # 此处会创建 预测单
inbound.finish_check()
return inbound
def off_the_shelf_func(sender, product_list, *args, **kwargs):
from core.options import log_action, CHANGE, get_systemoa_user
from .trade import SaleTrade
from flashsale.pay.tasks import notifyTradePayTask
sysoa_user = get_systemoa_user()
for pro_bean in product_list:
all_cart = ShoppingCart.objects.filter(item_id=pro_bean.id,
status=ShoppingCart.NORMAL,
type=0)
for cart in all_cart:
cart.close_cart()
log_action(sysoa_user.id, cart, CHANGE, u'下架后更新')
all_trade = SaleTrade.objects.filter(sale_orders__item_id=pro_bean.id,
status=SaleTrade.WAIT_BUYER_PAY)
for trade in all_trade:
try:
charge = xiaolupay.Charge.retrieve(trade.tid)
if charge and charge.paid:
notifyTradePayTask.delay(charge)
else:
trade.close_trade()
log_action(sysoa_user.id, trade, CHANGE, u'系统更新待付款状态到交易关闭')
except Exception, exc:
logger.error(exc.message, exc_info=True)
def task_auto_exchg_xlmm_order():
import datetime
tt = datetime.datetime.now()
tf = tt - datetime.timedelta(days=2)
from flashsale.pay.models.trade import SaleOrder, SaleTrade, Customer
from flashsale.xiaolumm.models import OrderCarry, XiaoluMama, ExchangeSaleOrder
from flashsale.pay.models import ModelProduct
exchg_orders = OrderCarry.objects.filter(
carry_type=OrderCarry.REFERAL_ORDER,
status__in=[OrderCarry.CONFIRM],
created__range=(datetime.date(2017, 2, 1), tf))
unexchg_coupon_num = 0
autoexchg_coupon_num = 0
if exchg_orders.exists():
for entry in exchg_orders.iterator():
sale_order = SaleOrder.objects.filter(oid=entry.order_id).first()
exchg_sale_order = ExchangeSaleOrder.objects.filter(
order_oid=entry.order_id).first()
if not sale_order:
continue
if sale_order.extras.has_key('exchange') or (
exchg_sale_order and exchg_sale_order.has_exchanged):
continue
model_product = ModelProduct.objects.filter(
id=sale_order.item_product.model_id,
is_boutique=True,
product_type=ModelProduct.VIRTUAL_TYPE).first()
if model_product:
from flashsale.pay.apis.v1.order import get_pay_type_from_trade
if round(sale_order.payment / sale_order.price
) > 0 and model_product.extras.has_key('template_id'):
unexchg_coupon_num += round(sale_order.payment /
sale_order.price)
from flashsale.xiaolumm.apis.v1.xiaolumama import get_mama_by_id
level1_mama = get_mama_by_id(entry.contributor_id)
level2_mama = get_mama_by_id(entry.mama_id)
if level2_mama:
level3_mama = level2_mama.get_referal_from_mama()
if level1_mama and level2_mama \
and level1_mama.get_level_lowest_elite() >= level2_mama.get_level_lowest_elite():
from flashsale.coupon.apis.v1.transfer import create_present_elite_score, get_elite_score_by_templateid
from flashsale.coupon.apis.v1.coupontemplate import get_coupon_template_by_id
autoexchg_coupon_num += round(sale_order.payment /
sale_order.price)
customer = level2_mama.get_customer()
template = get_coupon_template_by_id(
model_product.extras['template_id'])
product_id, elite_score, agent_price = get_elite_score_by_templateid(
template.id, level2_mama)
elite_score *= round(sale_order.payment /
sale_order.price)
uni_key_prefix = "autoexchg-%s" % (sale_order.id)
try:
create_present_elite_score(customer, elite_score,
template, '',
uni_key_prefix)
except IntegrityError:
logger.info({
'message':
u'task_auto_exchg_xlmm_order integrity err | oid=%s'
% (sale_order.oid),
})
if level2_mama.referal_from == XiaoluMama.INDIRECT and level3_mama and level3_mama.is_elite_mama:
entry.mama_id = level3_mama.id
entry.save(update_fields=['mama_id'])
from core.options import log_action, CHANGE, ADDITION, get_systemoa_user
sys_oa = get_systemoa_user()
log_action(
sys_oa, entry, CHANGE,
u'auto exchange ordercarry=%s,so=%s,level1 %s >= level2 %s,level2 %s to level3 %s'
% (entry.id, sale_order.oid,
level1_mama.get_level_lowest_elite(),
level2_mama.get_level_lowest_elite(),
level2_mama.id, level3_mama.id))
# print 'add level3', sale_order.oid, level1_mama.id, level2_mama.id, level3_mama.id
else:
exchg_sale_order = ExchangeSaleOrder.objects.filter(
order_oid=entry.order_id).first()
if not exchg_sale_order:
exchg_record = ExchangeSaleOrder(
order_oid=entry.order_id,
has_exchanged=True,
exchg_type=1,
uni_key=entry.order_id)
exchg_record.save()
else:
exchg_sale_order.has_exchanged = True
exchg_sale_order.exchg_type = 1
exchg_sale_order.save()
from core.options import log_action, CHANGE, ADDITION, get_systemoa_user
sys_oa = get_systemoa_user()
log_action(
sys_oa, exchg_sale_order, CHANGE,
u'auto exchange ordercarry=%s,level1 %s >= level2 %s,level2 %s, level3 none or not elite, so %s exchg finish'
% (entry.id,
level1_mama.get_level_lowest_elite(),
level2_mama.get_level_lowest_elite(),
level2_mama.id, sale_order.oid))
# print 'chg so', sale_order.oid, level1_mama.id, level2_mama.id
logger.info({
'message':
u'task_auto_exchg_xlmm_order | mama unexchg_coupon_num=%s autoexchg_coupon_num=%s'
% (unexchg_coupon_num, autoexchg_coupon_num),
})
def task_period_check_mama_renew_state():
"""
定时检查代理是否需要续费
1. 如果当前时间大于下次续费时间 修改 状态到冻结状态
"""
now = datetime.datetime.now()
sys_oa = get_systemoa_user()
# 续费 状态处理
effect_elite_mms = XiaoluMama.objects.filter(
status=XiaoluMama.EFFECT,
charge_status=XiaoluMama.CHARGED,
referal_from__in=[XiaoluMama.DIRECT, XiaoluMama.INDIRECT]).exclude(last_renew_type=XiaoluMama.ELITE) # 有效并接管的
for emm in effect_elite_mms.iterator():
try:
if (emm.renew_time and now >= emm.renew_time) or (not emm.renew_time):
# 2017-2-7 精英妈妈不冻结,变为单纯精英妈妈，老的99／188妈妈冻结
if emm.last_renew_type != XiaoluMama.ELITE:
emm.last_renew_type = XiaoluMama.ELITE
emm.save(update_fields=['last_renew_type'])
log_action(sys_oa, emm, CHANGE, u'schedule task: renew timeout,chg to elitemama')
except TypeError as e:
logger.error(u"task_period_check_mama_renew_state FROZEN mama:%s, error info: %s" % (emm.id, e))
max_mmid = 0
effect_no_elite_mms = XiaoluMama.objects.filter(
status=XiaoluMama.EFFECT,
charge_status=XiaoluMama.CHARGED).exclude(referal_from__in=[XiaoluMama.DIRECT, XiaoluMama.INDIRECT])
max_mmid = XiaoluMama.objects.all().count()
if effect_no_elite_mms.count() < 10000:
for emm in effect_no_elite_mms.iterator():
try:
if (emm.renew_time and now >= emm.renew_time) or ((not emm.renew_time) and emm.last_renew_type < XiaoluMama.ELITE):
emm.status = XiaoluMama.FROZEN
emm.save(update_fields=['status'])
log_action(sys_oa, emm, CHANGE, u'schedule task: renew timeout,chg to frozen')
except TypeError as e:
logger.error(u"task_period_check_mama_renew_state FROZEN mama:%s, error info: %s" % (emm.id, e))
else:
mmid = 100000
while True:
effect_no_elite_mms = XiaoluMama.objects.filter(
status=XiaoluMama.EFFECT,
charge_status=XiaoluMama.CHARGED,
id__lte=mmid).exclude(
referal_from__in=[XiaoluMama.DIRECT, XiaoluMama.INDIRECT])
for emm in effect_no_elite_mms.iterator():
try:
if (emm.renew_time and now >= emm.renew_time) or (
(not emm.renew_time) and emm.last_renew_type < XiaoluMama.ELITE):
emm.status = XiaoluMama.FROZEN
emm.save(update_fields=['status'])
log_action(sys_oa, emm, CHANGE, u'schedule task: renew timeout,chg to frozen')
except TypeError as e:
logger.error(u"task_period_check_mama_renew_state FROZEN mama:%s, error info: %s" % (emm.id, e))
if mmid < max_mmid:
mmid += 100000
else:
break
def double_mama_score():
from flashsale.coupon.models.transfer_coupon import CouponTransferRecord
from_time = datetime.datetime(2017, 2, 8, 23, 0, 0, 0)
to_time = datetime.datetime(2017, 2, 8, 23, 30, 0, 0)
has_add = CouponTransferRecord.objects.filter(
transfer_status=CouponTransferRecord.DELIVERED,
transfer_type__in=[CouponTransferRecord.IN_GIFT_COUPON],
created__range=(from_time, to_time)
)
has_add_mms = [p['coupon_to_mama_id'] for p in has_add.values('coupon_to_mama_id')]
from flashsale.xiaolumm.models import XiaoluMama
mamas = XiaoluMama.objects.filter(referal_from__in=[XiaoluMama.DIRECT, XiaoluMama.INDIRECT], status=XiaoluMama.EFFECT,
charge_status=XiaoluMama.CHARGED, elite_score__gt=0)
for mama in mamas.iterator():
origin_score = mama.elite_score
score = mama.elite_score
if mama.id in has_add_mms:
gift_ct = CouponTransferRecord.objects.filter(
coupon_to_mama_id=mama.id,
transfer_status=CouponTransferRecord.DELIVERED,
transfer_type__in=[CouponTransferRecord.IN_GIFT_COUPON],
created__range=(from_time, to_time)
).first()
if mama.elite_score >= 600 and mama.elite_score < 2000:
score = 600 - gift_ct.elite_score + 300
elif mama.elite_score >= 2000 and mama.elite_score < 6000:
score = 2000 - gift_ct.elite_score + 1000
elif mama.elite_score >= 6000 and mama.elite_score < 20000:
score = 6000 - gift_ct.elite_score + 3000
elif mama.elite_score >= 20000:
score = 20000 - gift_ct.elite_score + 10000
else:
if score >= 600 and score < 1000:
score += 300
elif score >= 2000 and score < 3000:
score += 1000
elif score >= 6000 and score < 10000:
score += 3000
if mama.elite_score != score:
mama.elite_score = score
mama.save()
from core.options import log_action, CHANGE, ADDITION, get_systemoa_user
sys_oa = get_systemoa_user()
log_action(sys_oa, mama, CHANGE, u'0208升级分数翻倍修改用户积分从%s到%s' % (origin_score, score))
try:
from flashsale.coupon.apis.v1.transfer import create_present_elite_score
from flashsale.coupon.apis.v1.coupontemplate import get_coupon_template_by_id
from flashsale.pay.apis.v1.customer import get_customer_by_id
if score > origin_score:
template = get_coupon_template_by_id(id=374)
customer = get_customer_by_id(mama.customer_id)
transfer_in = create_present_elite_score(customer, int(score - origin_score), template, 1)
log_action(sys_oa, transfer_in, ADDITION, '0208升级分数翻倍赠送积分: 赠送')
# log_action(sys_oa, transfer_out, ADDITION, '0208升级分数翻倍赠送积分: 消耗')
except Exception as e:
pass
def task_referal_update_awardcarry(relationship):
# print "%s, mama_id: %s" % (get_cur_info(), relationship.referal_from_mama_id)
if relationship.referal_type == XiaoluMama.ELITE:
return
from_mama_id = relationship.referal_from_mama_id
to_mama_id = relationship.referal_to_mama_id
carry_type = 1 # 直接推荐
# uni_key = util_unikey.gen_awardcarry_unikey(from_mama_id, to_mama_id)
uni_key = AwardCarry.gen_uni_key(to_mama_id, carry_type)
rr_cnt = ReferalRelationship.objects.filter(
referal_from_mama_id=from_mama_id,
referal_type__gte=XiaoluMama.HALF).exclude(
referal_to_mama_id=to_mama_id).count()
rr_cnt += 1
carry_num = utils.get_award_carry_num(rr_cnt, relationship.referal_type)
status = 1
carry_description = u'加入正式会员，奖金就会确认哦！'
if relationship.is_confirmed():
status = 2 # confirmed
carry_description = util_description.get_awardcarry_description(
carry_type)
else:
# 20161229 delete试用3的邀请奖励预计收益，只有正式的才有
return
award_carry = AwardCarry.objects.filter(uni_key=uni_key).first()
if award_carry:
from core.options import log_action, CHANGE, get_systemoa_user
logmsg = 'mama_id:%s->%s|carry_num:%s->%s|status:%s->%s' % (
award_carry.mama_id, from_mama_id, award_carry.carry_num,
carry_num, award_carry.status, status)
update_fields = []
if award_carry.mama_id != from_mama_id:
award_carry.mama_id = from_mama_id
update_fields.append('mama_id')
if award_carry.carry_num != carry_num:
award_carry.carry_num = carry_num
update_fields.append('carry_num')
if award_carry.status != status:
award_carry.status = status
update_fields.append('status')
if status == 2:
award_carry.date_field = datetime.date.today()
update_fields.append('date_field')
if award_carry.carry_description != carry_description:
award_carry.carry_description = carry_description
update_fields.append('carry_description')
if update_fields:
update_fields.append('modified')
award_carry.save(update_fields=update_fields)
sys_oa = get_systemoa_user()
log_action(sys_oa, award_carry, CHANGE, logmsg)
return
if not award_carry:
date_field = relationship.created.date()
award_carry = AwardCarry(
mama_id=from_mama_id,
carry_num=carry_num,
carry_type=carry_type,
carry_description=carry_description,
contributor_nick=relationship.referal_to_mama_nick,
contributor_img=relationship.referal_to_mama_img,
contributor_mama_id=relationship.referal_to_mama_id,
date_field=date_field,
uni_key=uni_key,
status=status)
award_carry.save()
def task_update_group_awardcarry(relationship):
from flashsale.xiaolumm.models.models_fortune import AwardCarry, ReferalRelationship, GroupRelationship
if relationship.referal_type == XiaoluMama.ELITE:
return
from_mama_id = relationship.referal_from_grandma_id
to_mama_id = relationship.referal_to_mama_id
carry_type = 2 # 团队推荐
status = 1
carry_description = u'%s推荐，加入正式会员，奖金就会确认哦！' % relationship.referal_from_mama_id
if relationship.is_confirmed():
status = 2 # confirmed
carry_description = util_description.get_awardcarry_description(
carry_type)
else:
# 20161229 delete试用3的邀请奖励预计收益，只有正式的才有
return
direct_referal_num = ReferalRelationship.objects.filter(
referal_from_mama_id=from_mama_id,
referal_type__gte=XiaoluMama.HALF).count()
group_referal_num = ReferalRelationship.objects.filter(
referal_from_grandma_id=from_mama_id,
referal_type__gte=XiaoluMama.HALF).exclude(
referal_to_mama_id=to_mama_id).count()
group_num = direct_referal_num + group_referal_num + 1
carry_num = utils.get_group_carry_num(group_num)
# if direct_referal_num >= 15, at least get 1000 cents for group referal
if carry_num <= 0 and direct_referal_num >= 15:
carry_num = 1000
if carry_num <= 0:
return
uni_key = AwardCarry.gen_uni_key(to_mama_id, carry_type)
award_carry = AwardCarry.objects.filter(uni_key=uni_key).first()
if award_carry:
from core.options import log_action, CHANGE, get_systemoa_user
logmsg = 'mama_id:%s->%s|carry_num:%s->%s|status:%s->%s' % (
award_carry.mama_id, from_mama_id, award_carry.carry_num,
carry_num, award_carry.status, status)
update_fields = []
if award_carry.mama_id != from_mama_id:
award_carry.mama_id = from_mama_id
update_fields.append('mama_id')
if award_carry.carry_num != carry_num:
award_carry.carry_num = carry_num
update_fields.append('carry_num')
if award_carry.status != status:
award_carry.status = status
update_fields.append('status')
if status == 2:
award_carry.date_field = datetime.date.today()
update_fields.append('date_field')
if award_carry.carry_description != carry_description:
award_carry.carry_description = carry_description
update_fields.append('carry_description')
if update_fields:
update_fields.append('modified')
award_carry.save(update_fields=update_fields)
sys_oa = get_systemoa_user()
log_action(sys_oa, award_carry, CHANGE, logmsg)
return
date_field = relationship.created.date()
award_carry = AwardCarry(
mama_id=from_mama_id,
carry_num=carry_num,
carry_type=carry_type,
contributor_nick=relationship.referal_to_mama_nick,
contributor_img=relationship.referal_to_mama_img,
contributor_mama_id=relationship.referal_to_mama_id,
date_field=date_field,
uni_key=uni_key,
status=status)
award_carry.save()
def task_auto_shelf_prods():
"""
1. 自动上架产品： 已经审核的产品 并且在下架状态的产品 修改状态到上架
2. 自动下架产品： 并且在上架状态的产品 修改状态到下架状态
"""
try:
from pms.supplier.models import SaleProductManage, SaleProductManageDetail
today = datetime.date.today()
t1 = datetime.datetime(today.year, today.month, today.day, 0, 0, 0)
t2 = datetime.datetime(today.year, today.month, today.day, 23, 59, 59)
schedules = SaleProductManage.objects.filter(upshelf_time__gte=t1, upshelf_time__lte=t2)
sale_product_ids = [] # 要上架的排期管理选品id
for schedule in schedules:
sale_product_ids += [d.sale_product_id for d in
schedule.manage_schedule.filter(today_use_status=SaleProductManageDetail.NORMAL)]
systemoa = get_systemoa_user()
offshelf_models = ModelProduct.offshelf_right_now_models()
onshelf_models = ModelProduct.upshelf_right_now_models()
onshelf_models = onshelf_models.filter(saleproduct_id__in=sale_product_ids)
offshelf_pros = Product.offshelf_right_now_products() # 要立即下架的产品
onshelf_pros = Product.upshelf_right_now_products() # 要立即上架的产品
onshelf_pros = onshelf_pros.filter(sale_product__in=sale_product_ids)
logger.warn({
'action': 'auto_off_shelf_models',
'auto_off_shelf_models_ids': ','.join([str(x[0]) for x in offshelf_models.values_list('id')]),
'auto_off_shelf_models_count': offshelf_models.count()}) # 下架款式log记录
for off_md in offshelf_models.iterator():
state_off = off_md.offshelf_model()
if state_off:
log_action(systemoa, off_md, CHANGE, u'系统自动下架款式')
logger.warn({
'action': 'auto_off_shelf_pros',
'auto_off_shelf_pros_ids': ','.join([str(x[0]) for x in offshelf_pros.values_list('id')]),
'auto_off_shelf_pros_count': offshelf_pros.count()
}) # 下架产品log记录
for off_pro in offshelf_pros.iterator():
state = off_pro.offshelf_product() # 执行下架动作
if state: # 上架成功 打log
log_action(systemoa, off_pro, CHANGE, u'系统自动下架修改该产品到下架状态')
logger.warn({
'action': 'auto_on_shelf_models',
'auto_on_shelf_models_ids': ','.join([str(x[0]) for x in onshelf_models.values_list('id')]),
'auto_on_shelf_models_count': onshelf_models.count()
}) # 上架款式log记录
for on_md in onshelf_models.iterator():
state_on = on_md.upshelf_model()
if state_on:
log_action(systemoa, on_md, CHANGE, u'系统自动上架款式')
logger.warn({
'action': 'auto_on_shelf_prods',
'auto_on_shelf_prods_ids': ','.join([str(x[0]) for x in onshelf_pros.values_list('id')]),
'auto_on_shelf_prods_count': onshelf_pros.count()
})
for on_pro in onshelf_pros.iterator():
state = on_pro.upshelf_product() # 执行上架动作
if state: # 上架成功 打log
log_action(systemoa, on_pro, CHANGE, u'系统自动上架修改该产品到上架状态')
except Exception as exc:
raise task_auto_shelf_prods.retry(countdown=60 * 5, exc=exc)
