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())