def post(self, request):
user = request.user
flag = request.DATA.get('flag')
phone = request.DATA.get('phone')
if not phone or not flag or (flag and int(flag) not in (1, 2)):
return Response({'ret_code': 20001, 'message': u'数据输入不合法'})
try:
user_book = UserPhoneBook.objects.filter(user=user,
phone=phone).first()
if not user_book:
return Response({'ret_code': 20002, 'message': u'被提醒用户不存在'})
profile = user.wanglibaouserprofile
send_name = profile.name if profile.id_is_valid else safe_phone_str(
profile.phone)
# 投资提醒
if int(flag) == 1:
if not (user_book.alert_at and user_book.alert_at >
local_to_utc(datetime.now(), 'min')):
# self._send_sms(phone, sms_messages.sms_alert_invest(name=send_name))
# 邀请投资提醒短信
# 模板中的参数变量必须以 name=value 的形式传入
PHPSendSMS().send_sms_one(5,
phone,
'phone',
name=send_name)
user_book.alert_at = timezone.now()
user_book.is_used = True
user_book.save()
# 邀请提醒
elif int(flag) == 2:
if User.objects.filter(
wanglibaouserprofile__phone=phone).exists():
user_book.is_register = True
if IntroducedBy.objects.filter(
introduced_by=user,
user_wanglibaouserprofile__phone=phone).exists():
user_book.is_invite = True
user_book.is_used = True
user_book.save()
if not user_book.is_register and not (
user_book.invite_at and user_book.invite_at >
local_to_utc(datetime.now(), 'min')):
# 邀请注册提醒短信
# 模板中的参数变量必须以 name=value 的形式传入
aws = base64.b64encode(profile.phone)[0:-1]
PHPSendSMS().send_sms_one(6,
phone,
'phone',
name=send_name,
aws=aws)
user_book.invite_at = timezone.now()
user_book.save()
return Response({'ret_code': 0, 'message': 'ok'})
except Exception, e:
logger.error(e.message)
return Response({'ret_code': 20003, 'message': u'内部程序错误'})
def getYesterdayTop10Ranks():
yesterday = datetime.datetime.now() - datetime.timedelta(1)
yesterday_start = local_to_utc(yesterday, 'min')
yesterday_end = local_to_utc(yesterday, 'max')
top_ranks = P2PRecord.objects.filter(
catalog='申购',
create_time__gte=yesterday_start,
create_time__lte=yesterday_end).values('user').annotate(
Sum('amount')).order_by('-amount__sum')[:10]
return top_ranks
def margin_records(request):
pagesize = request.DATA.get("pagesize", "10").strip()
page = request.DATA.get("page", "1").strip()
if not pagesize.isdigit() or not page.isdigit():
return {"ret_code": 80001, "message": u"请输入正确的参数"}
pagesize = int(pagesize)
page = int(page)
if pagesize > 100:
return {"ret_code": 80002, "message": u"参数超出限制"}
user = request.user
# 展示的起始时间为2016年2月8日,此前有账单变动的用户由此时间开始展示,历史数据不展示
date_start = local_to_utc(datetime.datetime(2016, 2, 8), 'min')
records = MarginRecord.objects.filter(user=user, create_time__gt=date_start).order_by('-id')[(page-1)*pagesize:page*pagesize]
res = []
for record in records:
obj = {
"id": record.id,
"catalog": MARGIN_CATALOG_MAPPING.get(record.catalog, record.catalog),
"catalog_sign": MARGIN_CATALOG_SIGN_MAPPING.get(record.catalog, ''),
"create_time": util.fmt_dt_normal(util.local_datetime(record.create_time)),
"amount": float(record.amount),
"margin_current": float(record.margin_current),
"description": record.description,
"order_id": record.order_id
}
res.append(obj)
return {"ret_code": 0, "data": res, "page": page}
def get_start_end_time(auto, auto_days, created_at, available_at,
unavailable_at):
if auto and auto_days > 0:
start_tmp = created_at
end_tmp = created_at + timezone.timedelta(days=int(auto_days))
from marketing.utils import local_to_utc
start_time = local_to_utc(
datetime.datetime(start_tmp.year, start_tmp.month, start_tmp.day),
'min')
end_time = local_to_utc(
datetime.datetime(end_tmp.year, end_tmp.month, end_tmp.day), 'max')
else:
start_time = available_at
end_time = unavailable_at
return start_time, end_time
def get_context_data(self, **kwargs):
user = self.request.user
now = dt = timezone.now()
pm_17 = local_to_utc(
datetime.datetime(now.year, now.month, now.day, 17, 0, 0),
'normal')
if now > pm_17:
dt = now + datetime.timedelta(days=1)
experience_product = ExperienceProduct.objects.filter(
isvalid=True).first()
experience_amount = 0
experience_amount_default = 28888.00
margin = 0
# 体验金可用余额
if user.is_authenticated():
margin = user.margin.margin
experience_record = ExperienceEventRecord.objects.filter(user=user, apply=False, event__invalid=False)\
.filter(event__available_at__lt=now, event__unavailable_at__gt=now).aggregate(Sum('event__amount'))
if experience_record.get('event__amount__sum'):
experience_amount = experience_record.get('event__amount__sum')
else:
experience_amount = experience_amount_default
return {
'product': experience_product,
'experience_amount': experience_amount,
'margin': margin,
'dt': dt.strftime("%Y-%m-%d"),
}
def _query_play_list(self, day, redpack):
play_list = PlayList.objects.filter(
play_at=local_to_utc(day, 'min'),
redpackevent=redpack).select_related(
'user__wanglibaouserprofile').order_by('-amount', 'ranking',
'created_at')
return play_list
def _generate_records(day, rule):
""" 统计生产新数据
"""
amount_min, amount_max, start, end, reward, exchange, redpack = rule
tops = Top(limit=0)
records = tops.day_tops_first_come_first_served(
day=day, amount_min=amount_min, amount_max=amount_max)[start:end]
play_set_list = []
n = 0
for record in records:
play = PlayList()
play.play_at = local_to_utc(day, source_time='min')
play.user = User.objects.get(id=record['user'])
play.amount = record['amount_sum']
reward_user = reward + (n * exchange) if exchange else reward
play.reward = reward_user
play.redpackevent = redpack
play.ranking = n + 1
if amount_min: play.amount_min = amount_min
if amount_max: play.amount_max = amount_max
if start: play.start = start
if end: play.end = end
play_set_list.append(play)
n += 1
if play_set_list:
PlayList.objects.bulk_create(play_set_list)
return True
def post(self, request):
phone_book = UserPhoneBook.objects.filter(user=request.user,
is_used=True,
is_register=False)
books, register_list = list(), list()
for book in phone_book:
if User.objects.filter(
wanglibaouserprofile__phone=book.phone).exists():
register_list.append(book.phone)
else:
books.append({
'name':
book.name,
'phone':
book.phone,
'status':
True if
not (book.invite_at and
book.invite_at > local_to_utc(datetime.now(), 'min'))
else False,
})
if register_list:
UserPhoneBook.objects.filter(
user=request.user,
phone__in=register_list).update(is_register=True)
return Response({'ret_code': 0, 'message': 'success', 'books': books})
def getTodayTop10Ranks():
today = datetime.datetime.now()
today_start = local_to_utc(today, 'min')
today_end = local_to_utc(today, 'max')
top_ranks = P2PRecord.objects.filter(
catalog='申购', create_time__gte=today_start,
create_time__lte=today_end).values('user').annotate(
Sum('amount')).order_by('-amount__sum')[:10]
uids = [rank['user'] for rank in top_ranks]
userprofiles = WanglibaoUserProfile.objects.filter(user__in=uids).all()
for rank in top_ranks:
for userprofile in userprofiles:
if userprofile.user_id == rank['user']:
rank['phone'] = safe_phone_str(userprofile.phone)
break
return top_ranks
def get_withdraw_success_count(user):
""" 获取当月成功提现次数 """
now = datetime.datetime.now()
month_start = local_to_utc(datetime.datetime(now.year, now.month, 1),
'min')
withdraw_count = PayInfo.objects.filter(user=user, type='W').filter(status=u'成功')\
.filter(create_time__gt=month_start).count()
return withdraw_count
def check_unavailable_3_days():
"""
每天一次检查3天后到期的红包优惠券.发短息提醒投资.
直接用sql语句查询。
分两种情况查询,1为查询理财券活动的截止日期,2为查询动态截止日期的
"""
from django.db import connection
# 查询三天后的日期
days = 3
check_date = timezone.now() + timezone.timedelta(days=days)
start_date = utils.local_to_utc(check_date,
'min').strftime('%Y-%m-%d %H:%M:%S')
end_date = utils.local_to_utc(check_date,
'max').strftime('%Y-%m-%d %H:%M:%S')
cursor = connection.cursor()
sql = "SELECT COUNT(a.user_id), a.user_id, b.phone FROM " \
"(SELECT r.user_id, e.auto_extension AS is_auto, e.unavailable_at, " \
"DATE_ADD(r.created_at, INTERVAL e.auto_extension_days day) end_date " \
"FROM wanglibao_redpack_redpackrecord AS r, " \
"wanglibao_redpack_redpack AS p, " \
"wanglibao_redpack_redpackevent AS e " \
"WHERE r.redpack_id = p.id AND p.event_id = e.id and r.order_id is NULL) AS a, " \
"wanglibao_profile_wanglibaouserprofile AS b " \
"WHERE a.user_id = b.user_id " \
"AND ((a.is_auto = 0 AND a.unavailable_at > '{}' AND a.unavailable_at <= '{}') " \
"OR (a.is_auto = 1 AND a.end_date > '{}' AND a.end_date <= '{}')) " \
"GROUP BY a.user_id;".format(start_date, end_date, start_date, end_date)
cursor.execute(sql)
fetchall = cursor.fetchall()
data_messages = {}
for idx, item in enumerate(fetchall):
data_messages[idx] = {
'user_id': item[2],
'user_type': 'phone',
'params': {
'count': item[0],
'days': days
}
}
# 功能推送id: 1
PHPSendSMS().send_sms(rule_id=1, data_messages=data_messages, timeout=20)
def getDayTop3Ranks():
today = datetime.datetime.now()
today_start = local_to_utc(today, 'min')
top_ranks = MarginRecord.objects.filter(
catalog='交易冻结', create_time__gte=today_start).values('user').annotate(
Sum('amount')).order_by('-amount__sum')[:3]
uids = [rank['user'] for rank in top_ranks]
userprofiles = WanglibaoUserProfile.objects.filter(user__in=uids).all()
for rank in top_ranks:
for userprofile in userprofiles:
if userprofile.user_id == rank['user']:
rank['phone'] = safe_phone_str(userprofile.phone)
rank['sex'] = userprofile.name[0] + getUserSex(userprofile)
break
return top_ranks
def getWeekSum():
amount_week_sum = 0
try:
#today = datetime.datetime.now()
#week_frist_day = today + datetime.timedelta(days=-int(today.strftime('%u'))+1-2)
week_frist_day = getWeekBeginDay()
today_start = local_to_utc(week_frist_day, 'min')
#today_end = local_to_utc(today, 'max')
#week_sum = P2PRecord.objects.filter(catalog='申购', create_time__gte=today_start, create_time__lte=today_end).aggregate(Sum('amount'))
week_sum = P2PRecord.objects.filter(
catalog='申购',
create_time__gte=today_start).aggregate(Sum('amount'))
amount_week_sum = week_sum['amount__sum'] if week_sum[
'amount__sum'] else Decimal('0')
except Exception, e:
logger.error("====updateRedisWeekTopRank=======" + e.message)
def getWeekTop10Ranks():
#today = datetime.datetime.now()
#计算开始时间从上周六0点开始
#week_frist_day = today + datetime.timedelta(days=-int(today.strftime('%u'))+1-2)
week_frist_day = getWeekBeginDay()
today_start = local_to_utc(week_frist_day, 'min')
#today_end = local_to_utc(today, 'max')
top_ranks = P2PRecord.objects.filter(
catalog='申购', create_time__gte=today_start).values('user').annotate(
Sum('amount')).order_by('-amount__sum')[:10]
uids = [rank['user'] for rank in top_ranks]
userprofiles = WanglibaoUserProfile.objects.filter(user__in=uids).all()
for rank in top_ranks:
for userprofile in userprofiles:
if userprofile.user_id == rank['user']:
rank['phone'] = safe_phone_str(userprofile.phone)
break
return top_ranks
def get_context_data(self, **kwargs):
""" 根据条件查询累计投资
"""
status, message, data = self._filter_rule(**kwargs)
if not status:
return {"message": message}
day, rule = data['day'], data['rule']
amount_min, amount_max, start, end, reward, exchange, redpack = rule
play_list = PlayList.objects.filter(play_at=local_to_utc(day, 'min'),
redpackevent=redpack)
if play_list.count() > 0:
message = u'统计日期已经存在统计记录！'
else:
if not self._generate_records(day=day, rule=rule):
message = u'统计记录生成失败！'
if not message: message = u'统计结束！'
return self._return_format(message, day, redpack)
def send_redpack(day, desc, rtype='nil'):
now = timezone.now()
day = datetime.strptime(day, '%Y-%m-%d')
play_list = PlayList.objects.filter(checked_status=1,
play_at=local_to_utc(day, 'min'),
redpackevent=desc)
for play in play_list:
events = RedPackEvent.objects.filter(give_mode=rtype,
invalid=False,
give_start_at__lte=now,
give_end_at__gte=now,
describe=play.redpackevent,
amount=play.reward)
with transaction.atomic():
for event in events:
user = User.objects.get(id=play.user_id)
status, msg = give_activity_redpack(user=user,
event=event,
device_type='pc')
if status:
# 更新数据库状态
PlayList.objects.filter(pk=play.id).update(
checked_status=2)
# 发送站内信
message_content = u"您在本次打榜活动中获奖，奖励红包已发送到您的账户，请在个人账户红包中查看。感谢您对我们的支持与关注。"
inside_message.send_one.apply_async(
kwargs={
"user_id": user.id,
"title": u"打榜送红包",
"content": message_content,
"mtype": "activity"
})
break
def _alert_invest_status(self, user, phone_user):
try:
profile = phone_user.wanglibaouserprofile
phone_book = UserPhoneBook.objects.filter(
user=user, phone=profile.phone).first()
if phone_book:
if not (phone_book.alert_at and phone_book.alert_at >
local_to_utc(datetime.now(), 'min')):
phone_book.is_used = True
phone_book.save()
return True
else:
phone_book = UserPhoneBook()
phone_book.user = user
phone_book.phone = profile.phone
phone_book.name = profile.name
phone_book.is_register = True
phone_book.is_invite = True
phone_book.is_used = True
phone_book.save()
return True
return False
except Exception, e:
return False
def post(self, request):
user = request.user
now = datetime.now()
request_year = request.DATA.get('year', '')
request_month = request.DATA.get('month', '')
year = request_year if request_year else now.year
month = request_month if request_month else now.month
# current_month = '{}-{}'.format(now.year, now.month)
current_month = now.strftime('%Y-%m')
start = local_to_utc(datetime(int(year), int(month), 1), 'min')
if int(month) == 12:
end = local_to_utc(
datetime(int(year) + 1, 1, 1) - timedelta(days=1), 'max')
else:
end = local_to_utc(
datetime(int(year),
int(month) + 1, 1) - timedelta(days=1), 'max')
# 月份/月还款金额/月还款期数
if request_year and request_month:
amos_group = UserAmortization.objects.filter(user=user)\
.filter(term_date__gt=start, term_date__lte=end).order_by('term_date')\
.extra({'term_date': "DATE_FORMAT(term_date,'%%Y-%%m')"}).values('term_date')\
.annotate(Count('term_date')).annotate(Sum('principal')).annotate(Sum('interest'))\
.annotate(Sum('penal_interest')).annotate(Sum('coupon_interest')).order_by('term_date')
else:
amos_group = UserAmortization.objects.filter(user=user)\
.extra({'term_date': "DATE_FORMAT(term_date,'%%Y-%%m')"}).values('term_date')\
.annotate(Count('term_date')).annotate(Sum('principal')).annotate(Sum('interest'))\
.annotate(Sum('penal_interest')).annotate(Sum('coupon_interest')).order_by('term_date')
month_group = [{
'term_date':
amo.get('term_date'),
'term_date_count':
amo.get('term_date__count'),
'total_sum':
amo.get('principal__sum') + amo.get('interest__sum') +
amo.get('penal_interest__sum') + amo.get('coupon_interest__sum'),
'principal_sum':
amo.get('principal__sum'),
'interest_sum':
amo.get('interest__sum'),
'penal_interest_sum':
amo.get('penal_interest__sum'),
'coupon_interest_sum':
amo.get('coupon_interest__sum'),
} for amo in amos_group]
# 当月的还款计划
user_amortizations = UserAmortization.objects.filter(user=user)\
.filter(term_date__gt=start, term_date__lte=end)\
.select_related('product_amortization').select_related('product_amortization__product')\
.order_by('term_date')
if user_amortizations:
amo_list = _user_amortization_list(user_amortizations)
else:
amo_list = []
if not amo_list:
custom_month_data = {
'term_date': current_month,
'term_date_count': 0,
'total_sum': 0.0,
'principal_sum': 0.0,
'interest_sum': 0.0,
'penal_interest_sum': 0.0,
'coupon_interest_sum': 0.0,
}
month_group.append(custom_month_data)
month_group.sort(key=lambda x: x['term_date'])
return Response({
'ret_code': 0,
'data': amo_list,
'month_group': month_group,
'current_month': current_month,
})
def send_reward(start, end, amount_min, percent):
from wanglibao_sms.tasks import send_messages
from wanglibao_p2p.models import Earning
from order.utils import OrderHelper
from order.models import Order
from django.forms import model_to_dict
from wanglibao_margin.marginkeeper import MarginKeeper
from wanglibao.templatetags.formatters import safe_phone_str
from marketing.models import RewardRecord
from decimal import Decimal
start = datetime.strptime(start, '%Y-%m-%d')
end = datetime.strptime(end, '%Y-%m-%d')
# 审核通过，给用户发放奖励
reward_type = u'邀请送收益'
records = IntroducedByReward.objects.filter(
checked_status=0,
activity_start_at=local_to_utc(start, source_time='min'),
activity_end_at=local_to_utc(end, source_time='max'),
activity_amount_min=Decimal(amount_min),
percent_reward=Decimal(percent),
)
if not records.exists():
return
for record in records:
# with transaction.atomic():
user, introduced_by, reward_type, got_amount, product = record.user, record.introduced_by_person, reward_type, record.introduced_reward, record.product
reward = Reward.objects.filter(is_used=False, type=reward_type).first()
# 发送短信
# text_content = u"【网利宝】您在邀请好友送收益的活动中，获得%s元收益，收益已经发放至您的网利宝账户。请注意查收。" % got_amount
# send_messages.apply_async(kwargs={
# "phones": [introduced_by.wanglibaouserprofile.phone],
# "messages": [text_content]
# })
# 发放收益
earning = Earning()
earning.amount = got_amount
earning.type = 'I'
earning.product = product
order = OrderHelper.place_order(introduced_by,
Order.ACTIVITY,
u"邀请送收益活动赠送",
earning=model_to_dict(earning))
earning.order = order
keeper = MarginKeeper(introduced_by, order.pk)
# 赠送活动描述
desc = u'%s,邀请好友首次理财活动中，活赠%s元' % (
introduced_by.wanglibaouserprofile.name, got_amount)
earning.margin_record = keeper.deposit(got_amount,
description=desc,
catalog=u"邀请首次赠送")
earning.user = introduced_by
earning.save()
# 发放站内信
message_content = u"您在邀请好友送收益的活动中，您的好友%s在活动期间完成首次投资，根据活动规则，您获得%s元收益。<br/>\
<a href='/accounts/home/' target='_blank'>查看账户余额</a><br/>\
感谢您对我们的支持与关注。<br/>\
网利宝" % (safe_phone_str(
user.wanglibaouserprofile.phone), got_amount)
RewardRecord.objects.create(user=introduced_by,
reward=reward,
description=message_content)
inside_message.send_one.apply_async(
kwargs={
"user_id": introduced_by.id,
"title": u"邀请送收益活动",
"content": message_content,
"mtype": "activity"
})
IntroducedByReward.objects.filter(id=record.id).update(
checked_status=1)
class FetchXunleiCardAward(APIView):
permission_classes = (IsAuthenticated, )
def getReward(self, type):
with transaction.atomic():
reward = Reward.objects.select_for_update().filter(
type=type, is_used=False).first()
if reward:
reward.is_used = True
reward.save()
return reward
def post(self, request):
user = request.user
activity = Activity.objects.filter(code="fkflr").first()
if not activity:
return Response({"ret_code": -1, "message": "没有该活动"})
if activity.is_stopped:
return Response({"ret_code": -1, "message": "活动已经截止"})
now = timezone.now()
if activity.start_at > now:
return Response({"ret_code": -1, "message": "活动还未开始"})
if activity.end_at < now:
return Response({"ret_code": -1, "message": "活动已经结束"})
type = request.POST.get('type')
if not type or not type.isdigit() or int(type) not in (0, 1):
return Response({"ret_code": -1, "message": "type error"})
type = int(type)
code = activity.code + "_" + str(type)
try:
activity_reward_record, _ = ActivityRewardRecord.objects.get_or_create(
user=user, activity_code=code)
except IntegrityError, e:
return Response({"ret_code": -1, "message": "系统忙，请重试"})
if activity_reward_record.status:
return Response({"ret_code": -1, "message": "您已经领取过"})
w_user = WeixinUser.objects.filter(user=user).first()
if not w_user:
return Response({"ret_code": -1, "message": "请绑定服务号"})
reward = None
if type == 0: #bind vip card
bind_action_record = WeiXinUserActionRecord.objects.filter(
user_id=user.id, action_type='bind').first()
create_time = local_to_utc(
datetime.datetime.fromtimestamp(
bind_action_record.create_time))
if bind_action_record and create_time >= activity.start_at and create_time <= activity.end_at:
reward = self.getReward("七天迅雷会员")
else:
return Response({"ret_code": -1, "message": "您不是首次绑定用户哦～"})
if type == 1: #invest vip card
p2pRecord = P2PRecord.objects.filter(
user=request.user,
catalog=u'申购').order_by("create_time").first()
if p2pRecord and p2pRecord.create_time >= activity.start_at and p2pRecord.create_time <= activity.end_at and float(
p2pRecord.amount) >= 1000:
reward = self.getReward("一年迅雷会员")
else:
return Response({"ret_code": -1, "message": "您不满足领取条件~"})
if not reward:
return Response({"ret_code": -1, "message": "奖品已经领完"})
try:
with transaction.atomic():
record = ActivityRewardRecord.objects.select_for_update().get(
id=activity_reward_record.id)
if record.status:
reward.is_used = False
reward.save()
return Response({"ret_code": -1, "message": "您已经领取过"})
record.activity_desc = 'xunleivip reward_id=%s' % reward.id
record.status = True
record.save()
except Exception, e:
reward.is_used = False
reward.save()
logger.debug(traceback.format_exc())
return Response({"ret_code": -1, "message": "系统繁忙"})
0,
'message':
'ok',
'amount':
float(amount) + float(index_data['paidIncome']),
'income_num':
float(income_num),
'income_yesterday':
float(income_yesterday) +
float(index_data['yesterdayIncome'])
})
else:
# 未登陆用户 查询当月还款金额和当月还款项目
start = datetime(now.year, now.month, 1)
start_utc = local_to_utc(start, 'min')
ams = ProductAmortization.objects.filter(
settlement_time__range=(start_utc, timezone.now()),
settled=True)
for x in ams:
amount += x.principal + x.interest + x.penal_interest
# 增加 月利宝 产生的数据
index_data = get_php_index_data_logout(
settings.PHP_APP_INDEX_DATA_LOGOUT_URL)
return Response({
'ret_code':
0,
'message':
def post(self, request):
user = request.user
now = timezone.now()
start_dt = local_to_utc(datetime(2016, 6, 7), 'min')
user_joined = user.date_joined # 用户注册时间
device = split_ua(request)
device_type = decide_device(device['device_type'])
purchase_code = 'experience_purchase'
experience_product = ExperienceProduct.objects.filter(
isvalid=True).first()
if not experience_product:
return Response({'ret_code': 30001, 'message': u'体验标有误,请重试'})
total_amount = 0
total_amount_tmp = 0
# 查询用户符合条件的理财金记录
with transaction.atomic(savepoint=True):
# 锁表,主要用来锁定体验金投资时的动作
purchase_lock_record = ExperiencePurchaseLockRecord.objects.select_for_update().\
filter(user=user, purchase_code=purchase_code).first()
if not purchase_lock_record:
# 没有记录时创建一条
try:
purchase_lock_record = ExperiencePurchaseLockRecord.objects.create(
user=user,
purchase_code=purchase_code,
purchase_times=0)
except Exception:
logger.exception(
"Error: experience purchase err, user: %s, phone: %s" %
(user.id, user.wanglibaouserprofile.phone))
return Response({
'ret_code': 30003,
'message': u'体验金投资失败,请重试'
})
experience_record = ExperienceEventRecord.objects.filter(user=user, apply=False) \
.filter(event__invalid=False, event__available_at__lt=now, event__unavailable_at__gt=now)\
.select_related('event')
records_ids = ''
if experience_record:
catalog = u'购买体验标'
for i in experience_record:
total_amount_tmp += i.event.amount
buy_p2p = P2PRecord.objects.filter(user_id=user.id).exists()
buy_count = MarginRecord.objects.filter(
user_id=user.id, catalog=catalog).count()
if not buy_p2p:
if user_joined > start_dt:
# 如果查询到已经购买过至少 1 次体验标,则不再检测账户余额
if buy_count == 0:
if total_amount_tmp >= 28888 and user.margin.margin < 1:
return Response({
'ret_code': 30009,
'message': u'账户余额不足,请先充值'
})
for record in experience_record:
event = record.event
total_amount += event.amount
records_ids += str(record.id) + ','
record.apply = True
record.apply_amount = event.amount
record.apply_at = timezone.now()
record.apply_platform = device_type
record.save()
terms = get_amortization_plan(u'日计息一次性还本付息').generate(
total_amount,
experience_product.expected_earning_rate / 100.0,
timezone.now(), experience_product.period)
for index, term in enumerate(terms['terms']):
amortization = ExperienceAmortization()
amortization.product = experience_product
amortization.user = user
amortization.principal = term[1] # 本金
amortization.interest = term[2] # 利息
amortization.term = index + 1 # 期数
amortization.description = u'第%d期' % (index + 1)
amortization.term_date = term[6] - timedelta(days=1)
amortization.save()
# 从账户中扣除 1 元 (没有购买过体验标的情况)
if not buy_p2p:
if user_joined > start_dt:
if total_amount >= 28888 and buy_count == 0:
amount = 1.00
order_id = OrderHelper.place_order(
user, order_type=catalog, status=u'新建').id
margin_keeper = MarginKeeper(user=user,
order_id=order_id)
margin_keeper.reduce_margin_common(
amount, catalog=catalog, description=catalog)
# 更新当前的一组流水id
purchase_lock_record.purchase_times += 1
purchase_lock_record.description = records_ids
purchase_lock_record.save()
term_date = amortization.term_date
interest = amortization.interest
return Response({
'ret_code': 0,
'data': {
'amount': total_amount,
'term_date': term_date.strftime("%Y-%m-%d"),
'interest': interest
}
})
else:
return Response({
'ret_code': 30002,
'message': u'没有体验金记录,无法购买体验标'
})
def sendYesterdayTopRankAward():
rank_activity = Activity.objects.filter(code='march_awards').first()
# utc_now = timezone.now()
# today_start = local_to_utc(datetime.datetime.now(), 'min')
yesterday = datetime.datetime.now() - datetime.timedelta(1)
yesterday_end = datetime.datetime(year=yesterday.year,
month=yesterday.month,
day=yesterday.day,
hour=23,
minute=59,
second=59)
yesterday_end = local_to_utc(yesterday_end, "")
# yesterday_start = local_to_utc(yesterday, 'min')
if rank_activity and (
(not rank_activity.is_stopped) or
(rank_activity.is_stopped and rank_activity.stopped_at > yesterday_end)
) and rank_activity.start_at <= yesterday_end and rank_activity.end_at >= yesterday_end:
top_ranks = getYesterdayTop10Ranks()
misc = Misc.objects.filter(key='march_awards').first()
march_awards = json.loads(misc.value)
rank_awards = march_awards['rank_awards']
uids = [rank['user'] for rank in top_ranks]
users = User.objects.filter(id__in=uids).all()
now_date = datetime.date.today()
for index, rank in enumerate(top_ranks):
redpack_event_id = rank_awards[index]
redpack_event = RedPackEvent.objects.filter(
id=int(redpack_event_id)).first()
if not redpack_event:
logger.error('排名奖励，第%s名的奖励配置的id为%s的红包不存在,导致该排名的用户%s没有得到' %
(index + 1, redpack_event_id, rank['user']))
continue
for user in users:
if user.id == rank['user']:
if not ActivityRewardRecord.objects.filter(
create_date=now_date,
activity_code=u'march_awards',
user=user).exists():
ActivityRewardRecord.objects.create(
user=user,
activity_code=u'march_awards',
activity_desc=u'获得%s排名%s奖励' % (yesterday.date(),
(index + 1)))
with transaction.atomic():
rank_reward_record = ActivityRewardRecord.objects.select_for_update(
).filter(create_date=now_date,
activity_code=u'march_awards',
user=user).first()
if not rank_reward_record.redpack_record_id:
status, messege, redpack_record_id = give_activity_redpack_new(
user, redpack_event, 'all')
if not status:
logger.error('排名奖励，排名第%s名的用户%s没有得到%s,因为%s' %
(index + 1, rank['user'],
redpack_event_id, messege))
break
rank_reward_record.redpack_record_id = redpack_record_id
rank_reward_record.redpack_record_id_time = timezone.now(
)
rank_reward_record.status = True
rank_reward_record.save()
break
def experience_repayment_plan():
"""
体验标还款计划结算任务
每天下午17:00分开始执行
自动将当天17:00之间所有未结算的计划进行统一结算
结算的利息自动计入用户的资金账户余额
"""
print(u"Getting experience gold repayment plan to start!")
now = datetime.now()
# start = local_to_utc(datetime(now.year, now.month, now.day - 1, 17, 0, 0), 'normal')
end = local_to_utc(datetime(now.year, now.month, now.day, 17, 0, 0),
'normal')
phone_list = list()
message_list = list()
amortizations = ExperienceAmortization.objects.filter(
settled=False).filter(term_date__lt=end)
for amo_tmp in amortizations:
is_commit = False
with transaction.atomic(savepoint=True):
# 锁定还款计划
amo = ExperienceAmortization.objects.select_for_update().get(
pk=amo_tmp.id)
try:
# Add by hb on 2016-06-08 : 避免体验金还款重复结算
if amo.settled:
continue
amo.settled = True
amo.settlement_time = timezone.now()
amo.save()
if amo.interest > 0:
# 体验金利息计入用户账户余额
description = u"体验金利息入账:%s元" % amo.interest
user_margin_keeper = MarginKeeper(amo.user)
user_margin_keeper.deposit(amo.interest,
description=description,
catalog=u"体验金利息入账")
is_commit = True
except Exception, e:
logger.error(
u"experience repayment error, amortization id : %s , message: %s"
% (amo.id, e.message))
# 发站内信,利息大于6元
if amo_tmp.interest > 6 and is_commit:
user_profile = amo_tmp.user.wanglibaouserprofile
# 短信
phone_list.append(user_profile.phone)
message_list.append(
messages.experience_amortize(user_profile.name,
amo_tmp.interest))
# 站内信
title, content = messages.experience_amortize_msg(
user_profile.name, amo_tmp.product.name,
amo_tmp.product.period, timezone.now(), amo_tmp.interest)
inside_message.send_one.apply_async(
kwargs={
"user_id": amo_tmp.user.id,
"title": title,
"content": content,
"mtype": "amortize"
})
def add_introduced_award(start, end, amount_min, percent):
from models import IntroducedBy
from decimal import Decimal, ROUND_DOWN
from wanglibao_p2p.models import P2PRecord
start = datetime.strptime(start, '%Y-%m-%d')
end = datetime.strptime(end, '%Y-%m-%d')
start_utc = local_to_utc(start, source_time='min')
end_utc = local_to_utc(end, source_time='max')
# 增加控制条件，没有被统计过才在统计生成
if IntroducedByReward.objects.filter(activity_start_at=start_utc,
activity_end_at=end_utc).exists():
return False
# print '============begin============', datetime.now()
new_user = IntroducedBy.objects.filter(bought_at__range=(
start_utc, end_utc)).filter(introduced_by__isnull=False).exclude(
introduced_by__wanglibaouserprofile__utype__gt=0).select_related(
'user')
# print '============query new_user ok============', datetime.now()
query_set_list = []
num = 0
for first_user in new_user:
num += 1
# everyone
# print '============begin query p2precord============', datetime.now()
first_record = P2PRecord.objects.filter(
user=first_user.user,
create_time__range=(start_utc, end_utc),
catalog='申购',
product__status__in=[
u'满标待打款',
u'满标已打款',
u'满标待审核',
u'满标已审核',
u'还款中',
u'已完成',
]).order_by('create_time').first()
# print '============end query p2precord============', datetime.now()
# first trade min amount limit
if first_record is not None and first_record.amount >= Decimal(
amount_min):
reward = IntroducedByReward()
reward.user = first_user.user
reward.introduced_by_person = first_user.introduced_by
reward.product = first_record.product
reward.first_bought_at = first_user.bought_at
reward.first_amount = first_record.amount
# 计算被邀请人首笔投资总收益
amount_earning = Decimal(
Decimal(first_record.amount) *
(Decimal(first_record.product.period) / Decimal(12)) *
Decimal(first_record.product.expected_earning_rate) *
Decimal('0.01')).quantize(Decimal('0.01'), rounding=ROUND_DOWN)
reward.first_reward = amount_earning
# 邀请人活取被邀请人首笔投资收益
reward.introduced_reward = Decimal(
Decimal(first_record.amount) *
(Decimal(first_record.product.period) / Decimal(12)) *
Decimal(percent) * Decimal('0.01')).quantize(
Decimal('0.01'), rounding=ROUND_DOWN)
reward.activity_start_at = start_utc
reward.activity_end_at = end_utc
reward.activity_amount_min = Decimal(amount_min)
reward.percent_reward = Decimal(percent)
reward.checked_status = 0
# reward.save()
query_set_list.append(reward)
# print '============one record end============', datetime.now()
if len(query_set_list) == 100:
IntroducedByReward.objects.bulk_create(query_set_list)
query_set_list = []
if len(query_set_list) > 0:
IntroducedByReward.objects.bulk_create(query_set_list)
def post(self, request):
now = datetime.now()
amount, income_num, income_yesterday = 0, 0, 0
try:
if request.user and request.user.is_authenticated():
# 登陆用户 查询当天收益和累计收益
user = request.user
start_utc = local_to_utc(now, 'min')
yesterday_start = start_utc - timedelta(days=1)
yesterday_end = yesterday_start + timedelta(
hours=23, minutes=59, seconds=59)
p2p_equities = P2PEquity.objects.filter(
user=user,
confirm=True,
product__status__in=[
u'已完成',
u'满标待打款',
u'满标已打款',
u'满标待审核',
u'满标已审核',
u'还款中',
u'正在招标',
]).select_related('product')
for equity in p2p_equities:
amount += equity.pre_paid_interest # 累积收益
amount += equity.pre_paid_coupon_interest # 加息券加息收益
amount += equity.activity_interest # 活动收益
# if equity.confirm_at >= start_utc:
# income_num += equity.pre_paid_interest
# income_num += equity.pre_paid_coupon_interest
# income_num += equity.activity_interest
# 昨日收益
# 利息入账, 罚息入账, 活动赠送, 邀请赠送, 加息存入, 佣佣金存入, 全民淘金
income_yesterday_other = MarginRecord.objects.filter(user=user)\
.filter(create_time__gt=yesterday_start, create_time__lte=yesterday_end)\
.filter(catalog__in=[u'利息入账', u'罚息入账', u'加息存入', u'佣金存入', u'全民淘金']).aggregate(Sum('amount'))
if income_yesterday_other.get('amount__sum'):
income_yesterday += income_yesterday_other.get(
'amount__sum')
# 增加从PHP项目来的 昨日收益, 累计收益, 待收收益
url = 'https://' + request.get_host(
) + settings.PHP_APP_INDEX_DATA
try:
if int(request.get_host().split(':')[1]) > 7000:
url = settings.PHP_APP_INDEX_DATA_DEV
except Exception, e:
pass
try:
index_data = get_php_index_data(url, user.id)
except Exception, e:
index_data = {
"yesterdayIncome": 0,
"paidIncome": 0,
"unPaidIncome": 0
}
logger_yuelibao.debug(
u'in AppRepaymentAPIView, get_php_index_data请求失败!!! exception = {}'
.format(e.message))
return Response({
'ret_code':
0,
'message':
'ok',
'amount':
float(amount) + float(index_data['paidIncome']),
'income_num':
float(income_num),
'income_yesterday':
float(income_yesterday) +
float(index_data['yesterdayIncome'])
})
def send_reward_all(start, end, amount_min, percent):
from decimal import Decimal
from wanglibao_sms.tasks import send_messages
start = datetime.strptime(start, '%Y-%m-%d')
end = datetime.strptime(end, '%Y-%m-%d')
# 审核通过，给用户发放奖励
records = IntroducedByReward.objects.filter(
checked_status=0,
activity_start_at=local_to_utc(start, source_time='min'),
activity_end_at=local_to_utc(end, source_time='max'),
activity_amount_min=Decimal(amount_min),
percent_reward=Decimal(percent),
)
if not records.exists():
return
phone_user = []
# A 邀请 B
# A 邀请人， B 被邀请人
for record in records:
# 为被邀请人发收益
if record.user.wanglibaouserprofile.utype == '0':
reward_earning(record,
record.user,
record.introduced_reward,
record.product,
flag=1)
phone_user.append(record.user.wanglibaouserprofile.phone)
# 为邀请人发收益
if record.introduced_by_person.wanglibaouserprofile.utype == '0':
reward_earning(record,
record.introduced_by_person,
record.introduced_reward,
record.product,
flag=2)
phone_user.append(
record.introduced_by_person.wanglibaouserprofile.phone)
if record.user.wanglibaouserprofile.utype != '0' and record.introduced_by_person.wanglibaouserprofile.utype != '0':
IntroducedByReward.objects.filter(id=record.id).update(
checked_status=1, checked_at=timezone.now())
phone_user = list(set(phone_user))
if phone_user:
# 发送短信
# text_content = u'好友邀请收益已经到账，请在个人账户中进行查看。'
# send_messages.apply_async(kwargs={
# "phones": phone_user,
# "messages": [text_content]
# })
# 发放站内信
inside_message.send_batch.apply_async(
kwargs={
"users": phone_user,
"title": u"邀请送收益活动",
"content": u'好友邀请收益已经到账，请在个人账户中进行查看。',
"mtype": "activity"
})
def add_introduced_award_all(start, end, amount_min, percent):
""" 邀请好友各的0.3%收益
1、活动期间邀请注册账户？
2、活动期间邀请注册账户购买产品
3、邀请人是经纪人怎么处理？
4、被邀请人是经纪人怎么处理？
"""
from models import IntroducedBy
from decimal import Decimal, ROUND_DOWN
from wanglibao_p2p.models import P2PRecord
from wanglibao_p2p.amortization_plan import get_base_decimal, get_final_decimal
start = datetime.strptime(start, '%Y-%m-%d')
end = datetime.strptime(end, '%Y-%m-%d')
start_utc = local_to_utc(start, source_time='min')
end_utc = local_to_utc(end, source_time='max')
# 增加控制条件，没有被统计过才在统计生成
if IntroducedByReward.objects.filter(activity_start_at=start_utc,
activity_end_at=end_utc).exists():
return False
new_user = IntroducedBy.objects.filter(
bought_at__range=(start_utc, end_utc)).filter(
created_at__range=(start_utc, end_utc)).filter(
introduced_by__isnull=False).select_related('user')
if not new_user.exists():
return
query_set_list = []
num = 0
for first_user in new_user:
num += 1
# 所有投资的产品
records = P2PRecord.objects.filter(user=first_user.user,
create_time__range=(start_utc,
end_utc),
catalog='申购',
product__status__in=[
u'满标待打款',
u'满标已打款',
u'满标待审核',
u'满标已审核',
u'还款中',
u'已完成',
]).order_by('create_time')
# 不存在投资记录，循环下一个用户
if not records.exists():
continue
# 首笔投资大于200才有收益
if records.first().amount < Decimal(amount_min):
continue
for record in records:
reward = IntroducedByReward()
reward.user = first_user.user
reward.introduced_by_person = first_user.introduced_by
reward.product = record.product
reward.first_bought_at = record.create_time
reward.first_amount = record.amount
# 计算被邀请人首笔投资总收益（收益年化）
reward.first_reward = get_base_decimal(
Decimal(record.amount) *
Decimal(record.product.expected_earning_rate) * Decimal(0.01) *
Decimal(record.product.period) / 12)
# 邀请人活取被邀请人首笔投资（投资年化）
got_amount = get_base_decimal(
Decimal(record.amount) * Decimal(percent) * Decimal(0.01) *
Decimal(record.product.period) / 12)
reward.introduced_reward = got_amount
reward.activity_start_at = start_utc
reward.activity_end_at = end_utc
reward.activity_amount_min = Decimal(amount_min)
reward.percent_reward = Decimal(percent)
reward.checked_status = 0
# 新增字段
if first_user.user.wanglibaouserprofile.utype == '0':
reward.user_send_amount = got_amount
if first_user.introduced_by.wanglibaouserprofile.utype == '0':
reward.introduced_send_amount = got_amount
query_set_list.append(reward)
if len(query_set_list) == 100:
IntroducedByReward.objects.bulk_create(query_set_list)
query_set_list = []
if len(query_set_list) > 0:
IntroducedByReward.objects.bulk_create(query_set_list)
