grassrootseconomics/cic-stack
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

The great bump

Browse Source
This commit is contained in:
Philip Wafula
2021-08-06 16:29:01 +00:00
parent f764b73f66
commit 0672a17d2e
195 changed files with 5791 additions and 4983 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
apps/cic-ussd/cic_ussd/processor/__init__.py Normal file
View File

305
apps/cic-ussd/cic_ussd/processor/menu.py Normal file
View File

@@ -0,0 +1,305 @@
# standard imports
import json
import logging
# external imports
import i18n.config
from sqlalchemy.orm.session import Session
# local imports
from cic_ussd.account.balance import calculate_available_balance, get_balances, get_cached_available_balance
from cic_ussd.account.chain import Chain
from cic_ussd.account.metadata import get_cached_preferred_language
from cic_ussd.account.statement import (
get_cached_statement,
parse_statement_transactions,
query_statement,
statement_transaction_set
)
from cic_ussd.account.transaction import from_wei, to_wei
from cic_ussd.account.tokens import get_default_token_symbol
from cic_ussd.cache import cache_data_key, cache_data
from cic_ussd.db.models.account import Account
from cic_ussd.metadata import PersonMetadata
from cic_ussd.phone_number import Support
from cic_ussd.processor.util import latest_input, parse_person_metadata
from cic_ussd.translation import translation_for
logg = logging.getLogger(__name__)
class MenuProcessor:
def __init__(self, account: Account, display_key: str, menu_name: str, session: Session, ussd_session: dict):
self.account = account
self.display_key = display_key
self.identifier = bytes.fromhex(self.account.blockchain_address[2:])
self.menu_name = menu_name
self.session = session
self.ussd_session = ussd_session
def account_balances(self) -> str:
"""
:return:
:rtype:
"""
available_balance = get_cached_available_balance(self.account.blockchain_address)
logg.debug('Requires call to retrieve tax and bonus amounts')
tax = ''
bonus = ''
token_symbol = get_default_token_symbol()
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
return translation_for(
key=self.display_key,
preferred_language=preferred_language,
available_balance=available_balance,
tax=tax,
bonus=bonus,
token_symbol=token_symbol
)
def account_statement(self) -> str:
"""
:return:
:rtype:
"""
cached_statement = get_cached_statement(self.account.blockchain_address)
statement = json.loads(cached_statement)
statement_transactions = parse_statement_transactions(statement)
transaction_sets = [statement_transactions[tx:tx+3] for tx in range(0, len(statement_transactions), 3)]
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
first_transaction_set = []
middle_transaction_set = []
last_transaction_set = []
if transaction_sets:
first_transaction_set = statement_transaction_set(preferred_language, transaction_sets[0])
if len(transaction_sets) >= 2:
middle_transaction_set = statement_transaction_set(preferred_language, transaction_sets[1])
if len(transaction_sets) >= 3:
last_transaction_set = statement_transaction_set(preferred_language, transaction_sets[2])
if self.display_key == 'ussd.kenya.first_transaction_set':
return translation_for(
self.display_key, preferred_language, first_transaction_set=first_transaction_set
)
if self.display_key == 'ussd.kenya.middle_transaction_set':
return translation_for(
self.display_key, preferred_language, middle_transaction_set=middle_transaction_set
)
if self.display_key == 'ussd.kenya.last_transaction_set':
return translation_for(
self.display_key, preferred_language, last_transaction_set=last_transaction_set
)
def help(self):
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
return translation_for(self.display_key, preferred_language, support_phone=Support.phone_number)
def person_metadata(self) -> str:
"""
:return:
:rtype:
"""
person_metadata = PersonMetadata(self.identifier)
cached_person_metadata = person_metadata.get_cached_metadata()
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
if cached_person_metadata:
return parse_person_metadata(cached_person_metadata, self.display_key, preferred_language)
absent = translation_for('helpers.not_provided', preferred_language)
return translation_for(
self.display_key,
preferred_language,
full_name=absent,
gender=absent,
age=absent,
location=absent,
products=absent
)
def pin_authorization(self, **kwargs) -> str:
"""
:param kwargs:
:type kwargs:
:return:
:rtype:
"""
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
if self.account.failed_pin_attempts == 0:
return translation_for(f'{self.display_key}.first', preferred_language, **kwargs)
remaining_attempts = 3
remaining_attempts -= self.account.failed_pin_attempts
retry_pin_entry = translation_for(
'ussd.kenya.retry_pin_entry', preferred_language, remaining_attempts=remaining_attempts
)
return translation_for(
f'{self.display_key}.retry', preferred_language, retry_pin_entry=retry_pin_entry
)
def start_menu(self):
"""
:return:
:rtype:
"""
token_symbol = get_default_token_symbol()
blockchain_address = self.account.blockchain_address
balances = get_balances(blockchain_address, Chain.spec.__str__(), token_symbol, False)[0]
key = cache_data_key(self.identifier, ':cic.balances')
cache_data(key, json.dumps(balances))
available_balance = calculate_available_balance(balances)
query_statement(blockchain_address)
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
return translation_for(
self.display_key, preferred_language, account_balance=available_balance, account_token_name=token_symbol
)
def transaction_pin_authorization(self) -> str:
"""
:return:
:rtype:
"""
recipient_phone_number = self.ussd_session.get('data').get('recipient_phone_number')
recipient = Account.get_by_phone_number(recipient_phone_number, self.session)
tx_recipient_information = recipient.standard_metadata_id()
tx_sender_information = self.account.standard_metadata_id()
token_symbol = get_default_token_symbol()
user_input = self.ussd_session.get('data').get('transaction_amount')
transaction_amount = to_wei(value=int(user_input))
return self.pin_authorization(
recipient_information=tx_recipient_information,
transaction_amount=from_wei(transaction_amount),
token_symbol=token_symbol,
sender_information=tx_sender_information
)
def exit_insufficient_balance(self):
"""
:return:
:rtype:
"""
available_balance = get_cached_available_balance(self.account.blockchain_address)
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
session_data = self.ussd_session.get('data')
transaction_amount = session_data.get('transaction_amount')
transaction_amount = to_wei(value=int(transaction_amount))
token_symbol = get_default_token_symbol()
recipient_phone_number = self.ussd_session.get('data').get('recipient_phone_number')
recipient = Account.get_by_phone_number(recipient_phone_number, self.session)
tx_recipient_information = recipient.standard_metadata_id()
return translation_for(
self.display_key,
preferred_language,
amount=from_wei(transaction_amount),
token_symbol=token_symbol,
recipient_information=tx_recipient_information,
token_balance=available_balance
)
def exit_invalid_menu_option(self):
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
return translation_for(self.display_key, preferred_language, support_phone=Support.phone_number)
def exit_pin_blocked(self):
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
return translation_for('ussd.kenya.exit_pin_blocked', preferred_language, support_phone=Support.phone_number)
def exit_successful_transaction(self):
"""
:return:
:rtype:
"""
amount = int(self.ussd_session.get('data').get('transaction_amount'))
preferred_language = get_cached_preferred_language(self.account.blockchain_address)
if not preferred_language:
preferred_language = i18n.config.get('fallback')
transaction_amount = to_wei(amount)
token_symbol = get_default_token_symbol()
recipient_phone_number = self.ussd_session.get('data').get('recipient_phone_number')
recipient = Account.get_by_phone_number(phone_number=recipient_phone_number, session=self.session)
tx_recipient_information = recipient.standard_metadata_id()
tx_sender_information = self.account.standard_metadata_id()
return translation_for(
self.display_key,
preferred_language,
transaction_amount=from_wei(transaction_amount),
token_symbol=token_symbol,
recipient_information=tx_recipient_information,
sender_information=tx_sender_information
)
def response(account: Account, display_key: str, menu_name: str, session: Session, ussd_session: dict) -> str:
"""This function extracts the appropriate session data based on the current menu name. It then inserts them as
keywords in the i18n function.
:param account: The account in a running USSD session.
:type account: Account
:param display_key: The path in the translation files defining an appropriate ussd response
:type display_key: str
:param menu_name: The name by which a specific menu can be identified.
:type menu_name: str
:param session:
:type session:
:param ussd_session: A JSON serialized in-memory ussd session object
:type ussd_session: dict
:return: A string value corresponding the ussd menu's text value.
:rtype: str
"""
menu_processor = MenuProcessor(account, display_key, menu_name, session, ussd_session)
if menu_name == 'start':
return menu_processor.start_menu()
if menu_name == 'help':
return menu_processor.help()
if menu_name == 'transaction_pin_authorization':
return menu_processor.transaction_pin_authorization()
if menu_name == 'exit_insufficient_balance':
return menu_processor.exit_insufficient_balance()
if menu_name == 'exit_successful_transaction':
return menu_processor.exit_successful_transaction()
if menu_name == 'account_balances':
return menu_processor.account_balances()
if 'pin_authorization' in menu_name:
return menu_processor.pin_authorization()
if 'enter_current_pin' in menu_name:
return menu_processor.pin_authorization()
if 'transaction_set' in menu_name:
return menu_processor.account_statement()
if menu_name == 'display_user_metadata':
return menu_processor.person_metadata()
if menu_name == 'exit_invalid_menu_option':
return menu_processor.exit_invalid_menu_option()
if menu_name == 'exit_pin_blocked':
return menu_processor.exit_pin_blocked()
preferred_language = get_cached_preferred_language(account.blockchain_address)
return translation_for(display_key, preferred_language)

185
apps/cic-ussd/cic_ussd/processor/ussd.py Normal file
View File

@@ -0,0 +1,185 @@
# standard imports
from typing import Optional
# external imports
import celery
import i18n
from sqlalchemy.orm.session import Session
from tinydb.table import Document
# local imports
from cic_ussd.db.models.account import Account, create
from cic_ussd.db.models.base import SessionBase
from cic_ussd.db.models.ussd_session import UssdSession
from cic_ussd.menu.ussd_menu import UssdMenu
from cic_ussd.processor.menu import response
from cic_ussd.processor.util import latest_input, resume_last_ussd_session
from cic_ussd.session.ussd_session import create_or_update_session, persist_ussd_session
from cic_ussd.state_machine import UssdStateMachine
from cic_ussd.translation import translation_for
from cic_ussd.validator import is_valid_response
def handle_menu(account: Account, session: Session) -> Document:
"""
:param account:
:type account:
:param session:
:type session:
:return:
:rtype:
"""
if account.pin_is_blocked(session):
return UssdMenu.find_by_name('exit_pin_blocked')
if account.has_valid_pin(session):
last_ussd_session = UssdSession.last_ussd_session(account.phone_number, session)
if last_ussd_session:
return resume_last_ussd_session(last_ussd_session.state)
elif not account.has_preferred_language():
return UssdMenu.find_by_name('initial_language_selection')
else:
return UssdMenu.find_by_name('initial_pin_entry')
def get_menu(account: Account,
session: Session,
user_input: str,
ussd_session: Optional[dict]) -> Document:
"""
:param account:
:type account:
:param session:
:type session:
:param user_input:
:type user_input:
:param ussd_session:
:type ussd_session:
:return:
:rtype:
"""
user_input = latest_input(user_input)
if not ussd_session:
return handle_menu(account, session)
if user_input == '':
return UssdMenu.find_by_name(name='exit_invalid_input')
if user_input == '0':
return UssdMenu.parent_menu(ussd_session.get('state'))
session = SessionBase.bind_session(session)
state = next_state(account, session, user_input, ussd_session)
return UssdMenu.find_by_name(state)
def handle_menu_operations(chain_str: str,
external_session_id: str,
phone_number: str,
queue: str,
service_code: str,
session,
user_input: str):
"""
:param chain_str:
:type chain_str:
:param external_session_id:
:type external_session_id:
:param phone_number:
:type phone_number:
:param queue:
:type queue:
:param service_code:
:type service_code:
:param session:
:type session:
:param user_input:
:type user_input:
:return:
:rtype:
"""
session = SessionBase.bind_session(session=session)
account: Account = Account.get_by_phone_number(phone_number, session)
if account:
return handle_account_menu_operations(account, external_session_id, queue, session, service_code, user_input)
create(chain_str, phone_number, session)
menu = UssdMenu.find_by_name('account_creation_prompt')
preferred_language = i18n.config.get('fallback')
create_or_update_session(
external_session_id=external_session_id,
msisdn=phone_number,
service_code=service_code,
state=menu.get('name'),
session=session,
user_input=user_input)
persist_ussd_session(external_session_id, queue)
return translation_for('ussd.kenya.account_creation_prompt', preferred_language)
def handle_account_menu_operations(account: Account,
external_session_id: str,
queue: str,
session: Session,
service_code: str,
user_input: str):
"""
:param account:
:type account:
:param external_session_id:
:type external_session_id:
:param queue:
:type queue:
:param session:
:type session:
:param service_code:
:type service_code:
:param user_input:
:type user_input:
:return:
:rtype:
"""
phone_number = account.phone_number
s_query_person_metadata = celery.signature(
'cic_ussd.tasks.metadata.query_person_metadata', [account.blockchain_address], queue='cic-ussd')
s_query_person_metadata.apply_async()
s_query_preferences_metadata = celery.signature(
'cic_ussd.tasks.metadata.query_preferences_metadata', [account.blockchain_address], queue='cic-ussd')
s_query_preferences_metadata.apply_async()
existing_ussd_session = session.query(UssdSession).filter_by(external_session_id=external_session_id).first()
last_ussd_session = UssdSession.last_ussd_session(phone_number, session)
if existing_ussd_session:
menu = get_menu(account, session, user_input, existing_ussd_session.to_json())
else:
menu = get_menu(account, session, user_input, None)
if last_ussd_session:
ussd_session = create_or_update_session(
external_session_id, phone_number, service_code, user_input, menu.get('name'), session,
last_ussd_session.data
)
else:
ussd_session = create_or_update_session(
external_session_id, phone_number, service_code, user_input, menu.get('name'), session, None
)
menu_response = response(
account, menu.get('display_key'), menu.get('name'), session, ussd_session.to_json()
)
if not is_valid_response(menu_response):
raise ValueError(f'Invalid response: {response}')
persist_ussd_session(external_session_id, queue)
return menu_response
def next_state(account: Account, session, user_input: str, ussd_session: dict) -> str:
"""
:param account:
:type account:
:param session:
:type session:
:param user_input:
:type user_input:
:param ussd_session:
:type ussd_session:
:return:
:rtype:
"""
state_machine = UssdStateMachine(ussd_session=ussd_session)
state_machine.scan_data((user_input, ussd_session, account, session))
return state_machine.state

77
apps/cic-ussd/cic_ussd/processor/util.py Normal file
View File

@@ -0,0 +1,77 @@
# standard imports
import datetime
import json
# external imports
from cic_types.models.person import get_contact_data_from_vcard
from tinydb.table import Document
# local imports
from cic_ussd.menu.ussd_menu import UssdMenu
from cic_ussd.translation import translation_for
def latest_input(user_input: str) -> str:
"""
:param user_input:
:type user_input:
:return:
:rtype:
"""
return user_input.split('*')[-1]
def parse_person_metadata(cached_metadata: str, display_key: str, preferred_language: str) -> str:
"""This function extracts person metadata formatted to suite display on the ussd interface.
:param cached_metadata: Person metadata JSON str.
:type cached_metadata: str
:param display_key: Path to an entry in menu data in translation files.
:type display_key: str
:param preferred_language: An account's set preferred language.
:type preferred_language: str
:return:
:rtype:
"""
user_metadata = json.loads(cached_metadata)
contact_data = get_contact_data_from_vcard(user_metadata.get('vcard'))
full_name = f'{contact_data.get("given")} {contact_data.get("family")}'
date_of_birth = user_metadata.get('date_of_birth')
year_of_birth = date_of_birth.get('year')
present_year = datetime.datetime.now().year
age = present_year - year_of_birth
gender = user_metadata.get('gender')
products = ', '.join(user_metadata.get('products'))
location = user_metadata.get('location').get('area_name')
return translation_for(
key=display_key,
preferred_language=preferred_language,
full_name=full_name,
age=age,
gender=gender,
location=location,
products=products
)
def resume_last_ussd_session(last_state: str) -> Document:
"""
:param last_state:
:type last_state:
:return:
:rtype:
"""
# TODO [Philip]: This can be cleaned further
non_reusable_states = [
'account_creation_prompt',
'exit',
'exit_invalid_pin',
'exit_invalid_new_pin',
'exit_invalid_request',
'exit_pin_blocked',
'exit_pin_mismatch',
'exit_successful_transaction'
]
if last_state in non_reusable_states:
return UssdMenu.find_by_name('start')
return UssdMenu.find_by_name(last_state)