def __init__(self, url=None, username=None, password=None, test_mode=None):
self.logger = get_nexchange_logger(self.__class__.__name__, True, True)
if url is None:
self.url = settings.CARDPMT_API_URL
else:
self.url = url
if username is None:
username = settings.CARDPMT_API_ID
else:
username = username
if password is None:
password = settings.CARDPMT_API_PASS
else:
password = password
if test_mode is None:
test_mode = settings.CARDPMT_TEST_MODE
else:
test_mode = test_mode
if test_mode:
test_mode_int = 1
else:
test_mode_int = 0
login_params = self.LOGIN_PARAMETERS.format(username=username,
password=password)
test_params = self.TEST_MODE.format(test_mode_int=test_mode_int)
self.initial_url = '{}?{}&{}'.format(self.url, login_params,
test_params)
self.name = 'Mastercard-Internal'
self.payment_method = PaymentMethod.objects.get(
name__icontains=self.name)
self.order = None
def __init__(self):
self.logger = get_nexchange_logger(self.__class__.__name__, True, True)
self.api = Idenfy(
url=settings.IDENFY_URL,
version=settings.IDENFY_VERSION,
api_key=settings.IDENFY_API_KEY,
api_secret=settings.IDENFY_API_SECRET
)
def __init__(self):
self.start = 0
self.old_start = 0
self.api = None
self.related_nodes = []
self.logger = get_nexchange_logger(self.__class__.__name__)
self.mapper = None
self.cache = {}
def setUp(self):
super(BaseTestLiveOrders, self).setUp()
self.logger = get_nexchange_logger(
'Live Test Logger', with_email=False, with_console=True
)
self.private_key = 'private_key' # noqa
self.driver = webdriver.Chrome()
self.driver.set_window_size(1400, 1000)
def get_ticker_crypto_crypto(**kwargs):
logger = get_nexchange_logger(__name__, True, True)
pair_pk = kwargs.get('pair_pk', None)
validate_change = kwargs.get('validate_change', True)
if pair_pk:
ticker, price = crypto_crypto_ticker.run(pair_pk)
save_ticker_and_price(ticker, price, validate_change=validate_change)
else:
logger.warning('pair_pk is not defined in kwargs')
def check_suspicious_transactions_all_currencies_periodic():
logger = get_nexchange_logger('Suspicious Transaction Checker')
for curr in Currency.objects.filter(disabled=False, is_crypto=True,
is_token=False):
try:
check_suspicious_transactions_invoke.apply_async([curr])
except Exception as e:
logger.warning(e)
continue
def __init__(self, *args, **kwargs):
# Logging
self.logger = get_nexchange_logger(self.__class__.__name__, True, True)
# override to make next tasks wait for the
# end of the execution of the current task
self.immediate_apply = True
self.next_tasks = set()
super(BaseTask, self).__init__(*args, **kwargs)
def check_fiat_order_deposit_periodic():
logger = get_nexchange_logger('Periodic Fiat Order Deposit Checker')
pending_fiat_orders = Order.objects.filter(
flagged=False, status=Order.PAID_UNCONFIRMED, exchange=False
)
for order in pending_fiat_orders:
try:
check_fiat_order_deposit_invoke.apply_async([order.pk])
except Exception as e:
logger.logger.info(e)
def wrapper(self, *args):
logger = get_nexchange_logger(
self.__class__.__name__
)
try:
return fn(self, *args)
except Exception as e:
logger.error(
'Exception {} Traceback {}'.format(
e, get_traceback()))
def check_payments_for_void_periodic():
logger = get_nexchange_logger('Periodic Fiat Order Refund Checker')
payments = [
p for p in Payment.objects.filter(
is_success=True,
flagged=False,
order__status=Order.PAID_UNCONFIRMED
) if p.kyc_wait_void_period_expired
]
for payment in payments:
try:
check_payments_for_void_invoke.apply_async([payment.pk])
except Exception as e:
logger.logger.info(e)
def get_ticker_crypto_fiat(**kwargs):
pair_pk = kwargs.get('pair_pk', None)
validate_change = kwargs.get('validate_change', True)
logger = get_nexchange_logger(__name__, True, True)
if pair_pk:
pair = Pair.objects.get(pk=pair_pk)
ticker, price = crypto_fiat_ticker.run(pair_pk)
save_ticker_and_price(ticker, price, validate_change=validate_change)
if pair.name in settings.LOCALBTC_PAIRS:
ticker_loc, price_loc = crypto_fiat_ticker.run(
pair_pk, market_code='locbit')
# Always false because this is localbitcoin
save_ticker_and_price(ticker_loc, price_loc, validate_change=False)
else:
logger.warning('pair_pk is not defined in kwargs')
def buy_order_release_reference_periodic():
logger = get_nexchange_logger('Periodic Buy Order Release')
for payment in Payment.objects.filter(is_success=True,
is_redeemed=False,
flagged=False,
order__status=Order.PAID):
try:
order = payment.order
if order.coverable:
buy_order_release_by_reference_invoke.apply_async([payment.pk])
else:
logger.warning('Not enough funds to release order {}'.format(
order.unique_reference))
except Exception as e:
logger.warning(e)
def check_kyc_names_periodic():
logger = get_nexchange_logger('Periodic Fiat Order Deposit Checker')
pending_fiat_orders = Order.objects.filter(
flagged=False, status=Order.PAID_UNCONFIRMED, exchange=False
)
for order in pending_fiat_orders:
try:
payment = order.payment_set.get(type=Payment.DEPOSIT)
pref = payment.payment_preference
flagged_kycs = pref.verification_set.filter(flagged=True)
has_kyc = pref.is_verified
name_matches = pref.name_on_card_matches
if has_kyc and not name_matches and not flagged_kycs:
notify_about_wrong_kyc_name_invoke.apply_async([order.pk])
except Exception as e:
logger.logger.info(e)
def _get_all_tickers(validate_change=True):
logger = get_nexchange_logger('Get Tickers')
pairs = Pair.objects.filter(disable_ticker=False)
for pair in pairs:
kwargs = {'pair_pk': pair.pk, 'validate_change': validate_change}
if pair.is_crypto:
fn = get_ticker_crypto_crypto
else:
fn = get_ticker_crypto_fiat
try:
fn(**kwargs)
pair.last_price_saved = True
except Exception as e:
pair.last_price_saved = False
logger.warning(
'Smth is wrong with pair:{} ticker. traceback:{}'.format(
pair, e))
pair.save(update_fields=['last_price_saved'])
def update_pending_transactions():
logger = get_nexchange_logger(__name__, True, True)
next_tasks = set()
for tx in Transaction.objects. \
filter(Q(is_completed=False) | Q(is_verified=False), flagged=False): # noqa
try:
_update_pending_transaction(tx, logger, next_tasks=next_tasks)
except ValidationError as e:
logger.info(e)
except Exception as e:
logger.info(e)
for task, args in next_tasks:
if args is not None:
res = task.apply_async([args])
else:
res = task.apply_async()
if res.state != 'SUCCESS':
logger.error('Task {} returned error traceback: {}'.format(
task.name, res.traceback))
def exchange_order_release_periodic():
logger = get_nexchange_logger('Periodic Exchange Order Release')
dep_txs = Transaction.objects.filter(type=Transaction.DEPOSIT,
flagged=False)
txs = dep_txs.filter(
Q(order__exchange=True,
order__status=Order.PAID,
order__withdraw_address__isnull=False)
| Q(limit_order__status=LimitOrder.PAID,
limit_order__withdraw_address__isnull=False))
for tx in txs:
try:
order = tx.order if tx.order else tx.limit_order
if order.coverable:
exchange_order_release_invoke.apply_async([tx.pk])
else:
logger.warning('Not enough funds to release order {}'.format(
order.unique_reference))
except Exception as e:
logger.warning(e)
def perform_create(self, serializer):
instance = serializer.save()
try:
if self.request.user.is_authenticated:
instance.users.add(self.request.user)
if instance.email:
try:
user = User.objects.get(email=instance.email)
instance.users.add(user)
except User.DoesNotExist:
pass
instance.add_related_orders_and_users()
instance.referral_code = \
referral_middleware.get_referral_code(self.request)
instance.save()
except Error as e:
logger = get_nexchange_logger(__name__)
logger.error('Email Subscription User lookup error {} {}'
.format(instance.email, e))
super(SubscriptionViewSet, self).perform_create(serializer)
subscription_eth_balance_check_invoke.apply_async([instance.pk])
subscription_address_turnover_check_invoke.apply_async(
[instance.pk],
countdown=settings.FAST_TASKS_TIME_LIMIT
)
subscription_related_turnover_check_invoke.apply_async(
[instance.pk],
countdown=settings.FAST_TASKS_TIME_LIMIT * 2
)
subscription_token_balances_check_invoke.apply_async(
[instance.pk],
countdown=settings.FAST_TASKS_TIME_LIMIT * 3
)
subscription_category_check_invoke.apply_async(
[instance.pk],
countdown=settings.FAST_TASKS_TIME_LIMIT * 4
)
def check_kyc_pending_documents_periodic():
logger = get_nexchange_logger('PENDING KYC Documents Checker')
payment_preferences = PaymentPreference.objects.all()
for payment_preference in payment_preferences:
if payment_preference.verification_set.count() == 0:
continue
if not payment_preference.has_pending_documents:
continue
try:
for verification in payment_preference.verification_set.all():
for document in verification.verificationdocument_set.all():
doc_created = document.created_on.replace(tzinfo=None)
doc_pending_time = datetime.now() - doc_created
if doc_pending_time.days >= 1:
subject = 'Customer\'s verification document PENDING is too long' # noqa
message = 'Verification document status PENDING wasn\'nt changed from PENDING status for {} day(s)'.format(doc_pending_time.days) # noqa
payment_preference.notify(
email_to=settings.SUPPORT_EMAIL,
subject=subject,
message=message
)
except Exception as e:
logger.logger.info(e)
from django.db.models.signals import pre_save
from django.dispatch import receiver
from nexchange.utils import get_nexchange_logger
from orders.models import Order
logger = get_nexchange_logger('notify_order', True, True)
@receiver(pre_save, sender=Order)
def notify_orders(sender, instance=None, **kwargs):
try:
if instance is None:
return
if instance.pk is None:
return
status = instance.status
if status not in [Order.RELEASED]:
return
status_before = Order.objects.get(pk=instance.pk).status
if status == status_before:
return
instance.notify()
except Exception as e:
logger.warning('Unable to send order notification. error: {}'.format(e))
from django.db import models
from django.utils.dateformat import format
from django.conf import settings
from cached_property import cached_property_with_ttl
from core.models import Pair, Market, Currency
from core.common.models import IndexTimeStampedModel
from decimal import Decimal
from payments.utils import money_format
from django.utils import timezone
from django.utils.translation import ugettext as _
from django.core.exceptions import ValidationError
from nexchange.utils import get_nexchange_logger
LOGGER = get_nexchange_logger('Ticker Logger',
with_email=True,
with_console=True)
class Ticker(IndexTimeStampedModel):
ask = models.DecimalField(max_digits=18, decimal_places=8)
bid = models.DecimalField(max_digits=18, decimal_places=8)
pair = models.ForeignKey(Pair, on_delete=models.CASCADE)
@property
def rate(self):
return (self.ask + self.bid) / 2
def _validate_change(self):
if self.pk:
return
def __init__(self):
self.logger = get_nexchange_logger(self.__class__.__name__)
def __init__(self):
self.logger = get_nexchange_logger(self.__class__.__name__, True, True)
self.client = None
def __init__(self):
self.transactions = None
self.logger = get_nexchange_logger(self.__class__.__name__)
from functools import wraps
from nexchange.api_clients.factory import ApiClientFactory
from .models import Order, LimitOrder
from nexchange.utils import get_nexchange_logger
factory = ApiClientFactory()
logger = get_nexchange_logger('Orders Decorator logger')
def get_task(**kwargs):
def _get_task(task_fn):
@wraps(task_fn)
def _wrapped_fn(search_val):
Task = kwargs.get('task_cls')
key = kwargs.get('key')
lookup = {key: [search_val]}
try:
order = Order.objects.get(**lookup)
except Order.DoesNotExist:
order = None
try:
limit_order = LimitOrder.objects.get(**lookup)
except LimitOrder.DoesNotExist:
limit_order = None
if bool(limit_order) == bool(order):
logger.error(
'{} lookup for order found both Order and '
'LimitOrder'.format(lookup)
)
return
_order = order if order else limit_order
from verification.validators import validate_image_extension
from core.common.models import SoftDeletableModel, TimeStampedModel, \
FlagableMixin, NamedModel, RequestLog
from core.models import Currency, Country
from django.urls import reverse
from django.utils.translation import ugettext as _
from audit_log.models import AuthStampedModel
from django.utils.safestring import mark_safe
from nexchange.utils import get_nexchange_logger
from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
import datetime
from django.utils import timezone
logger = get_nexchange_logger('Verification logger',
with_email=True,
with_console=True)
class VerificationTier(TimeStampedModel):
name = models.CharField(max_length=255)
description = models.CharField(max_length=255)
level = models.IntegerField()
upgrade_note = models.CharField(max_length=255, default='Contact Support')
required_documents = models.ManyToManyField('verification.DocumentType')
whitelisting_required = models.BooleanField(default=False)
@classmethod
def get_relevant_tier(cls, obj):
# this is to support old verifications records which are approved by
# util_status and id_status on verification object
def __init__(self, api, wallet=None):
self.logger = get_nexchange_logger(self.__class__.__name__)
self.wallet_name = wallet
self.client = api
from django.db.models.signals import post_save
from django.dispatch import receiver
from nexchange.utils import get_nexchange_logger
from verification.models import VerificationDocument
logger = get_nexchange_logger('notify_verification', True, True)
def doc_status_changed(old_status, new_status):
return True if old_status != new_status else False
def meets_requirements_for_notification(obj):
if obj is None or obj.pk is None or obj.kyc_push \
or obj.document_status not in [obj.REJECTED, obj.OK] \
or not doc_status_changed(obj.original_document_status,
obj.document_status):
return False
ver = obj.verification
payment_preference = ver.payment_preference if ver else None
if payment_preference is None or payment_preference.user_email is None \
or not payment_preference._has_pending_orders:
return False
if any([payment_preference.has_pending_documents]):
return False
if obj.document_status == obj.REJECTED:
if payment_preference.get_payment_preference_document_status(
obj.document_type.name) == 'OK':
return False
return True
def user_get_or_create(request):
"""This is used for seemless fast login"""
logger = get_nexchange_logger('user_get_or_create')
login_with_email = request.POST.get('login_with_email', False) == 'true'
phone = request.POST.get('phone', '')
phone = sanitize_number(phone, True)
email = request.POST.get('email', '')
user_data = {}
profile_data = {}
if not login_with_email:
username = profile_data['phone'] = phone
_validator = validate_international_phonenumber
else:
username = user_data['email'] = email
_validator = validate_email
try:
_validator(username)
except ValidationError as e:
context = {'status': 'error', 'msg': str(e.message)}
user_login_failed.send(sender=User,
request=request,
credentials={'username': username})
return HttpResponse(json.dumps(context),
status=400,
content_type='application/json')
user_data['username'] = username
user, u_created = User.objects.get_or_create(**user_data)
if u_created:
profile_data['disabled'] = True
profile_data['user'] = user
Profile.objects.get_or_create(**profile_data)
try:
if not login_with_email:
res = send_auth_sms(user)
else:
res = send_auth_email(user)
except Exception as e:
logger.error('Exception: {} Traceback: {}'.format(e, get_traceback()))
error_tmpl = 'Our {} service provider is down. Please contact ' \
'administrator.'
if not login_with_email:
error_msg = _(error_tmpl.format('SMS'))
else:
error_msg = _(error_tmpl.format('EMAIL'))
context = {'status': 'error', 'message': str(error_msg)}
user_login_failed.send(sender=User,
request=request,
credentials={'username': username})
return HttpResponse(json.dumps(context),
status=503,
content_type='application/json')
if isinstance(res, Exception):
user_login_failed.send(sender=User,
request=request,
credentials={'username': username})
return JsonResponse({'status': 'error'})
else:
user_login_failed.send(sender=User,
request=request,
credentials={'username': username})
# user_logged_in.send(
# sender=User,
# request=request,
# user=user
# )
return JsonResponse({'status': 'ok'})
from django.conf import settings
from decimal import Decimal
from core.common.models import SoftDeletableModel, \
TimeStampedModel, FlagableMixin, NamedModel, RequestLog
from ticker.models import Price
from django.utils.timezone import now, timedelta
from core.models import Location, Country, BtcBase, Currency
from verification.models import VerificationDocument
import requests
from nexchange.utils import send_email, get_nexchange_logger
from smtplib import SMTPDataError
from django.utils import timezone
import datetime
logger = get_nexchange_logger('Payment logger',
with_email=True,
with_console=True)
class PaymentMethodManager(models.Manager):
def get_by_natural_key(self, bin_code):
return self.get(bin=bin_code)
DEFAULT_FEE_CURRENCY_PK = 4 # USD
class PaymentMethod(TimeStampedModel, SoftDeletableModel):
NATURAL_KEY = 'bin'
CUSTOMER = 0
