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