def send_success_sms(message_key: str, user: User, other_user: User, amount: float, reason: str, tx_time: datetime, balance: float): amount_dollars = rounded_dollars(amount) rounded_balance_dollars = rounded_dollars(balance) TokenProcessor.send_sms(user, message_key, amount=amount_dollars, token_name=default_token(user).symbol, other_user=other_user.user_details(), date=tx_time.strftime('%d/%m/%Y'), reason=reason, time=tx_time.strftime('%I:%M %p'), balance=rounded_balance_dollars)
def exchange_success_sms(message_key: str, user: User, other_user: User, own_amount: float, other_amount: float, tx_time: datetime, balance: float): rounded_own_amount_dollars = rounded_dollars(own_amount) rounded_other_amount_dollars = rounded_dollars(other_amount) rounded_balance_dollars = rounded_dollars(balance) TokenProcessor.send_sms( user, message_key, own_amount=rounded_own_amount_dollars, other_amount=rounded_other_amount_dollars, own_token_name=default_token(user).symbol, other_token_name=default_token(other_user).symbol, other_user=other_user.user_details(), date=tx_time.strftime('%d/%m/%Y'), time=tx_time.strftime('%I:%M %p'), balance=rounded_balance_dollars)
def fetch_exchange_rate(user: User): from_token = default_token(user) default_limit, limit_amount = TokenProcessor.get_default_limit( user, from_token) exchange_rate_full_precision = TokenProcessor.get_exchange_rate( user, from_token) exchange_limit = rounded_dollars(limit_amount) exchange_rate = round_to_sig_figs(exchange_rate_full_precision, 3) exchange_sample_value = round(exchange_rate_full_precision * float(1000)) if exchange_limit: TokenProcessor.send_sms( user, "exchange_rate_can_exchange_sms", token_name=from_token.symbol, exchange_rate=exchange_rate, exchange_limit=exchange_limit, exchange_sample_value=exchange_sample_value, limit_period=default_limit.time_period_days) else: TokenProcessor.send_sms( user, "exchange_rate_sms", token_name=from_token.symbol, exchange_rate=exchange_rate, exchange_sample_value=exchange_sample_value, )
def send_success_sms(message_key: str, user: User, other_user: User, amount: float, tx_time: datetime, balance: float): amount_dollars = rounded_dollars(amount) rounded_balance_dollars = rounded_dollars(balance) user_details = user.user_details().replace('+254', '0') other_user_details = other_user.user_details().replace('+254', '0') TokenProcessor.send_sms(user=user, message_key=message_key, amount=int(float(amount_dollars)), token_name=default_token(user).symbol, user_details=user_details, other_user_details=other_user_details, date=tx_time.strftime('%d/%m/%Y'), time=tx_time.strftime('%I:%M %p'), balance=int(float(rounded_balance_dollars)))
def ge_string(t): if t['limit'].transfer_balance_fraction: # TODO: This doesn't seem DRY with respect to 'get default exchange rate' allowed_amount = rounded_dollars( t['limit'].transfer_balance_fraction * t['balance']) rounded_rate = round_to_sig_figs(t['exchange_rate'], 3) return ( f"{allowed_amount} {t['name']} (1 {t['name']} = {rounded_rate} {reserve_token.symbol})" ) else: return ""
def exchange_token(sender: User, agent: User, amount: float): try: # TODO: do agents have default token being reserve? to_amount = TokenProcessor.transfer_token( sender, agent, amount, transfer_subtype=TransferSubTypeEnum.AGENT_OUT ) sender_tx_time = pendulum.now(sender.default_organisation.timezone) agent_tx_time = pendulum.now(agent.default_organisation.timezone) sender_balance = TokenProcessor.get_balance(sender) agent_balance = TokenProcessor.get_balance(agent) TokenProcessor.exchange_success_sms( "exchange_token_sender_sms", sender, agent, amount, to_amount, sender_tx_time, sender_balance ) TokenProcessor.exchange_success_sms( "exchange_token_agent_sms", agent, sender, to_amount, amount, agent_tx_time, agent_balance ) except NoTransferAllowedLimitError as e: TokenProcessor.send_sms( sender, "exchange_not_allowed_error_sms", ) except (TransferAmountLimitError, MinimumSentLimitError) as e: TokenProcessor.send_sms( sender, "exchange_amount_error_sms", amount=rounded_dollars(e.transfer_amount_limit), token=e.token, limit_period=e.limit_time_period_days ) except TransferBalanceFractionLimitError as e: TokenProcessor.send_sms( sender, "exchange_fraction_error_sms", token=e.token, percent=f"{int(e.transfer_balance_fraction_limit * 100)}%" ) except TransferCountLimitError as e: TokenProcessor.send_sms( sender, "exchange_count_error_sms", count=e.transfer_count_limit, token=e.token, limit_period=e.limit_time_period_days ) except MaximumPerTransferLimitError as e: TokenProcessor.send_sms( sender, "maximum_per_transaction_error_sms", token=e.token, amount=e.maximum_amount_limit )
def send_onboarding_sms_messages(user): # First send the intro message organisation = getattr(g, 'active_organisation', None) or user.default_organisation intro_message = i18n_for( user, "general_sms.welcome.{}".format(organisation.custom_welcome_message_key or 'generic'), first_name=user.first_name, balance=rounded_dollars(user.transfer_account.balance), token=user.transfer_account.token.name ) send_message(user.phone, intro_message) send_terms_message_if_required(user)
def send_token(sender: User, recipient: User, amount: float, reason_str: str, reason_id: int): try: exchanged_amount = TokenProcessor.transfer_token( sender, recipient, amount, reason_id) sender_tx_time = pendulum.now(sender.default_organisation.timezone) recipient_tx_time = pendulum.now( recipient.default_organisation.timezone) sender_balance = TokenProcessor.get_balance(sender) recipient_balance = TokenProcessor.get_balance(recipient) if exchanged_amount is None: TokenProcessor.send_success_sms("send_token_sender_sms", sender, recipient, amount, reason_str, sender_tx_time, sender_balance) TokenProcessor.send_success_sms("send_token_recipient_sms", recipient, sender, amount, reason_str, recipient_tx_time, recipient_balance) else: TokenProcessor.exchange_success_sms( "exchange_token_sender_sms", sender, recipient, amount, exchanged_amount, sender_tx_time, sender_balance) TokenProcessor.exchange_success_sms("exchange_token_agent_sms", recipient, sender, exchanged_amount, amount, recipient_tx_time, recipient_balance) except InsufficientBalanceError as e: token_balances_dollars, token_exchanges = TokenProcessor._get_token_balances( sender) TokenProcessor.send_sms(sender, "insufficient_balance_sms", amount=cents_to_dollars(amount), token_name=default_token(sender).name, recipient=recipient.user_details(), token_balances=token_balances_dollars) except TransferAmountLimitError as e: # Use a different message here from that used for exchange, # because the issue is caused by KYC (ie something the user can change by providing), rather than # our price-stability controls TokenProcessor.send_sms(sender, "transfer_amount_error_sms", amount=rounded_dollars( e.transfer_amount_limit), token=e.token, limit_period=e.limit_time_period_days) except Exception as e: # TODO: SLAP? all the others take input in cents TokenProcessor.send_sms(sender, "send_token_error_sms", amount=cents_to_dollars(amount), token_name=default_token(sender).name, recipient=recipient.user_details())