def list_withdraw(delta=86400):
from_time = get_now() - timedelta(seconds=delta)
result = client.get_withdraw_history(
startTime=int(from_time.timestamp() * 1000),
endTime=int(get_now().timestamp() * 1000),
)
if not result['success']:
raise Exception('Binance: Something wrong when get_withdraw_history')
return result['withdrawList']
def increase_limit(user, amount, currency, direction, fiat_local_amount,
fiat_local_currency):
# Convert local currency to user currency
update_amount = fiat_local_amount
if user.currency != fiat_local_currency:
update_amount = RateManagement.convert_currency(
update_amount, fiat_local_currency, user.currency)
UserLimit.objects.filter(user=user,
direction=DIRECTION_ALL,
fiat_currency=user.currency) \
.update(usage=F('usage') + update_amount,
updated_at=get_now())
Pool.objects.filter(direction=direction, currency=currency).update(
usage=F('usage') + amount, updated_at=get_now())
def check_cod_limit(user, local_amount, fiat_currency):
limit = {
FIAT_CURRENCY.USD: {
'min': Decimal('2000'),
'max': Decimal('3000'),
},
FIAT_CURRENCY.HKD: {
'min': Decimal('15000'),
'max': Decimal('25000'),
},
}
data = limit.get(fiat_currency)
if data:
exchange_user = user.exchange_user
if exchange_user.currency != fiat_currency:
check_amount = RateManagement.convert_currency(
local_amount, exchange_user.currency, fiat_currency)
if not (data['min'] <= check_amount <= data['max']):
raise CoinUserOverLimitException
now = get_now()
order = Order.objects.filter(
direction=DIRECTION.buy,
order_type=ORDER_TYPE.cod,
created_at__day=now.day,
created_at__month=now.month,
created_at__year=now.year,
).first()
if order:
raise CoinUserOverLimitException
else:
raise InvalidDataException
def get_queryset(self):
overdue = self.request.query_params.get('overdue')
qs = LoanTerm.objects.select_related('loan_applicant__application').all().order_by('-created_at')
if overdue is not None:
qs = qs.filter(pay_date__lte=get_now())
return qs
def generate_loan(self):
assert (self.status == LOAN_APPLICATION_STATUS.approved)
now = get_now()
end_date = now + timedelta(days=self.term * self.cycle)
applicant = LoanMemberApplication.objects.filter(application=self,
main=True).first()
Loan.objects.create(
application=self,
loan_applicant=applicant,
loan_amount=self.loan_amount,
start_date=now,
end_date=end_date,
)
original_amount = self.loan_amount / self.cycle
interest_amount = original_amount * self.rate / Decimal(100)
total_amount = original_amount + interest_amount
for i in range(1, self.cycle + 1):
LoanTerm.objects.create(
loan_applicant=applicant,
original_amount=original_amount,
interest_amount=interest_amount,
total_amount=total_amount,
pay_date=now + timedelta(days=i * self.term),
)
def pay(self):
if self.paid:
raise AlreadyPaidException
ConstantCoreBusiness.transfer(self.loan_applicant.member.user_id,
settings.CONSTANT_USER_ID,
self.total_amount)
now = get_now()
self.paid_date = now
self.paid = True
if self.paid_date < self.pay_date:
self.paid_status = LOAN_TERM_STATUS.paid
else:
self.paid_status = LOAN_TERM_STATUS.late_paid
obj = LoanPayment.objects.create(loan_applicant=self.loan_applicant,
paid_amount=self.total_amount,
original_amount=self.original_amount,
interest_amount=self.interest_amount,
fee=0)
self.payment = obj
self.save()
# All paid, close application
all_term = LoanTerm.objects.filter(
loan_applicant=self.loan_applicant).count()
paid_term = LoanTerm.objects.filter(loan_applicant=self.loan_applicant,
paid=True).count()
if all_term == paid_term:
LoanApplicationBusiness.objects.get(
id=self.loan_applicant.application.id).close()
class LoanTermFactory(factory.django.DjangoModelFactory):
class Meta:
model = 'loan.LoanTerm'
loan_applicant = factory.SubFactory(LoanMemberApplicationFactory)
original_amount = Decimal('10')
interest_amount = Decimal('0.15')
total_amount = Decimal('10.15')
pay_date = get_now()
paid_status = factory.Iterator([item[0] for item in LOAN_TERM_STATUS])
def expire_order():
now = get_now()
orders = Order.objects.filter(
created_at__lt=now - timedelta(seconds=ORDER_EXPIRATION_DURATION),
status=ORDER_STATUS.pending,
order_type=ORDER_TYPE.bank,
direction=DIRECTION.buy)
for order in orders:
order.status = ORDER_STATUS.expired
order.save(update_fields=['status', 'updated_at'])
def post(self, request, format=None):
now = get_now() + timedelta(days=10)
# Get all
terms = LoanTermBusiness.objects.filter(pay_date__day=now.day,
pay_date__month=now.month,
pay_date__year=now.year)
for term in terms:
try:
term.send_email_reminder()
term.send_sms_reminder()
except Exception as ex:
logging.exception(ex)
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.auth_utils.user_login()
ConstantCoreBusiness.transfer = MagicMock(return_value=None)
self.member = LoanMemberFactory(user_id=1)
app = LoanApplicationFactory(status=LOAN_APPLICATION_STATUS.approved)
mem_app = LoanMemberApplicationFactory(application=app,
member=self.member,
main=True)
self.loan_term = LoanTermFactory(loan_applicant=mem_app,
pay_date=get_now() +
timedelta(days=2))
def post(self, request, format=None):
now = get_now() - timedelta(days=3)
connecting_members = LoanMemberApplicationBusiness.objects.filter(
status=LOAN_MEMBER_APPLICATION_STATUS.connecting,
application__created_at__day=now.day,
application__created_at__month=now.month,
application__created_at__year=now.year,
)
for member in connecting_members:
try:
member.send_email_connection_reminder()
member.send_sms_connection_reminder()
except Exception as ex:
logging.exception(ex)
def test_user_list(self):
url = reverse('loan:loanterm-list')
member = LoanMemberFactory(user_id=1)
app = LoanApplicationFactory()
mem_app = LoanMemberApplicationFactory(application=app,
member=member,
main=True)
loan_term = LoanTermFactory(loan_applicant=mem_app,
pay_date=get_now() + timedelta(days=2))
LoanTermNotificationFactory(loan_term=loan_term)
LoanTermNotificationFactory(loan_term=loan_term)
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()['results']), 1)
def post(self, request, format=None):
now = get_now()
# Get all not pay yet
terms = LoanTermBusiness.objects.filter(pay_date__day=now.day,
pay_date__month=now.month,
pay_date__year=now.year,
paid=False)
for term in terms:
try:
term.pay()
except NotEnoughBalanceException:
try:
term.send_email_not_enough_balance()
term.send_sms_not_enough_balance()
except Exception as ex:
logging.exception(ex)
except Exception as ex:
logging.exception(ex)
def post(self, request, format=None):
now = get_now() - timedelta(days=7)
connected_member_condition = Q(loan_member_applications__main=False) & \
Q(loan_member_applications__status=LOAN_MEMBER_APPLICATION_STATUS.connected)
ref_member_condition = Q(loan_member_applications__main=False)
connected_member_count = Count('loan_member_applications',
filter=connected_member_condition)
ref_member_count = Count('loan_member_applications',
filter=ref_member_condition)
applications = LoanApplicationBusiness.objects\
.filter(status=LOAN_APPLICATION_STATUS.created,
created_at__day=now.day,
created_at__month=now.month,
created_at__year=now.year)\
.annotate(connected_member_count=connected_member_count,
ref_member_count=ref_member_count)
for application in applications:
if application.connected_member_count < application.ref_member_count:
application.reject()
def test_full_detail(self):
url = reverse('loan-admin:loanterm-list')
member = LoanMemberFactory()
member_sub1 = LoanMemberFactory()
member_sub2 = LoanMemberFactory()
app = LoanApplicationFactory()
mem_app = LoanMemberApplicationFactory(application=app,
member=member,
main=True)
LoanMemberApplicationFactory(application=app,
member=member_sub1,
main=False)
LoanMemberApplicationFactory(application=app,
member=member_sub2,
main=False)
LoanTermFactory(loan_applicant=mem_app,
pay_date=get_now() + timedelta(days=2))
response = self.client.get(url, format='json')
# print(response.json())
self.assertEqual(response.status_code, status.HTTP_200_OK)
def get_account():
return client.get_account(timestamp=get_now().timestamp())
def update_first_purchase(user: ExchangeUser):
if not user.first_purchase:
user.first_purchase = get_now()
user.save(update_fields=['first_purchase'])
def reset_user_limit():
UserLimit.objects.filter(direction=DIRECTION_ALL).update(
usage=0, updated_at=get_now())
def get_action_to_do():
reminder_actions = SystemReminderAction.objects.all()
actions = []
# order_action = verification_action = None
pending_order = ReminderManagement.check_pending_order()
pending_verification = ReminderManagement.check_pending_verification()
reminder_groups = {
NOTIFICATION_GROUP.order: {
'group': NOTIFICATION_GROUP.order,
'pending': pending_order,
},
NOTIFICATION_GROUP.notification: {
'group': NOTIFICATION_GROUP.notification,
'pending': pending_verification,
}
}
# If there are current actions
for reminder_action in reminder_actions:
# No pending anymore
if not reminder_groups[reminder_action.reminder.group]['pending']:
reminder_action.delete()
# Check if the action is not at on hold
if reminder_action.updated_at + timedelta(
seconds=60 * reminder_action.stop_duration) < get_now():
# Check if the action still have active time
if reminder_action.active_time:
# Check if the time is proper to do?
if reminder_action.updated_at + timedelta(
seconds=60 *
reminder_action.reminder.frequency) < get_now():
reminder_action.active_time = F('active_time') - 1
reminder_action.save()
actions.append(reminder_action)
else:
# Not, go next
# Check if the time is proper to do?
if reminder_action.updated_at + timedelta(
seconds=60 *
reminder_action.reminder.break_duration) < get_now(
):
reminder = ReminderManagement.get_next_reminder(
reminder_action.group, reminder_action.reminder.id)
reminder_action.reminder = reminder
reminder_action.active_time = reminder.times
reminder.save()
actions.append(reminder_action)
elif reminder_action.stop_duration:
# Time out of stop duration
# Just delete and the code below will add again to reset the action if needed
reminder_action.delete()
# There is no action, make one
if not actions:
for key, item in reminder_groups.items():
if item['pending']:
reminder = ReminderManagement.get_next_reminder(key)
if reminder:
action = SystemReminderAction.objects.create(
group=key,
active_reminder=reminder,
active_time=reminder.times - 1,
stop_duration=0,
)
actions.append(action)
return actions
def create_referral(order: Order):
try:
referrer = order.user.referral
except ExchangeUser.DoesNotExist:
return
if not referrer:
return
referee = order.user
referrals = []
referrer_rule = PromotionRule.objects.filter(
country=referrer.country, currency=referrer.currency,
active=True).first()
if referrer_rule:
percentage = referrer_rule.referrer_percentage
first_order = ReferralOrder.objects.filter(
user=referrer, referrer=True).order_by('created_at').first()
if first_order and referrer_rule.referrer_next_duration > 0 and \
first_order.created_at + timedelta(days=referrer_rule.referrer_next_duration) < get_now():
percentage = referrer_rule.referrer_percentage_2
bonus = (order.amount * percentage) / Decimal('100')
if bonus:
referrals.append(
ReferralOrder(
order=order,
user=referrer,
amount=bonus,
currency=order.currency,
referrer=True,
address=UserWalletManagement.get_default_address(
referrer, order.currency),
)),
referee_rule = PromotionRule.objects.filter(country=referee.country,
currency=referee.currency,
active=True).first()
if referee_rule:
percentage = referee_rule.referee_percentage
if referee.first_purchase and referee_rule.referrer_next_duration > 0 and \
referee.first_purchase + timedelta(days=referee_rule.referrer_next_duration) < get_now():
percentage = referee_rule.referee_percentage_2
bonus = (order.amount * percentage) / Decimal('100')
if bonus:
referrals.append(
ReferralOrder(
order=order,
user=referee,
amount=bonus,
currency=order.currency,
referrer=True,
address=UserWalletManagement.get_default_address(
referee, order.currency),
)),
if referrals:
ReferralOrder.objects.bulk_create(referrals)
def get_due_days(self, instance):
return (get_now() - instance.pay_date).days
def reset_user_limit():
UserLimit.objects.all().update(usage=0, updated_at=get_now())
