def track_api_call(self,
remote_addr,
s_req,
s_resp,
action_name,
processed_data,
curs=None):
super(HelixbillingApplication,
self).track_api_call(remote_addr, s_req, s_resp, action_name,
processed_data)
actor_user_id = processed_data.get('actor_user_id')
custom_actor_info = processed_data.get('custom_actor_info')
environment_id = processed_data.get('environment_id')
users_ids = processed_data.get('subject_users_ids', [])
session_id = processed_data.get('session_id')
data = {
'environment_id': environment_id,
'session_id': session_id,
'custom_actor_info': custom_actor_info,
'actor_user_id': actor_user_id,
'subject_users_ids': users_ids,
'action': action_name,
'remote_addr': remote_addr,
'request': s_req,
'response': s_resp,
}
mapping.insert(curs, ActionLog(**data))
def add_tariff(self, data, session, curs=None):
# checking parent tariff exist
pt_id = data['parent_tariff_id']
currency = data.get('currency', None)
t_data = {
'environment_id': session.environment_id,
'parent_tariff_id': pt_id,
'name': data['name'],
'type': data['type'],
'status': data['status']
}
if pt_id is not None:
if currency is not None:
raise NonParentTariffWithCurrency
else:
t_f = TariffFilter(session, {'id': pt_id}, {}, None)
t_f.filter_one_obj(curs)
elif currency is None:
raise ParentTariffWithoutCurrency
else:
c_f = CurrencyFilter({'code': currency}, {}, None)
c = c_f.filter_one_obj(curs)
t_data['currency_id'] = c.id
t = Tariff(**t_data)
mapping.insert(curs, t)
return response_ok(id=t.id)
def _process_lock(self, session, curs, data, operation, balance_updater):
lock_f = BalanceLockFilter(session, {
'id': data['lock_id'],
'balance_id': data['balance_id']
}, {}, None)
lock = lock_f.filter_one_obj(curs)
balance = self._get_active_balance(session, curs, data)
currs_id_idx = self._get_currs_idx(curs, 'id')
currency = currs_id_idx[balance.currency_id]
info = data.get('info', {})
trans_data = {
'environment_id': session.environment_id,
'user_id': balance.user_id,
'balance_id': balance.id,
'currency_code': currency.code,
'type': operation,
'real_amount': cents_to_decimal(currency, lock.real_amount),
'virtual_amount': cents_to_decimal(currency, lock.virtual_amount),
'order_id': lock.order_id,
'info': info
}
balance_updater(balance, lock)
mapping.update(curs, balance)
trans = Transaction(**trans_data)
mapping.delete(curs, lock)
mapping.insert(curs, trans)
return response_ok(transaction_id=trans.id)
def _process_lock(self, session, curs, data, operation, balance_updater):
lock_f = BalanceLockFilter(session, {'id': data['lock_id'],
'balance_id': data['balance_id']}, {}, None)
lock = lock_f.filter_one_obj(curs)
balance = self._get_active_balance(session, curs, data)
currs_id_idx = self._get_currs_idx(curs, 'id')
currency = currs_id_idx[balance.currency_id]
info = data.get('info', {})
trans_data = {'environment_id': session.environment_id, 'user_id': balance.user_id,
'balance_id': balance.id, 'currency_code': currency.code, 'type': operation,
'real_amount': cents_to_decimal(currency, lock.real_amount),
'virtual_amount': cents_to_decimal(currency, lock.virtual_amount),
'order_id': lock.order_id, 'info': info}
balance_updater(balance, lock)
mapping.update(curs, balance)
trans = Transaction(**trans_data)
mapping.delete(curs, lock)
mapping.insert(curs, trans)
return response_ok(transaction_id=trans.id)
def _make_income_transaction(self, curs, data, session, transaction_type):
balance = self._get_active_balance(session, curs, data)
currs_id_idx = self._get_currs_idx(curs, 'id')
currency = currs_id_idx[balance.currency_id]
amount_dec = Decimal(data['amount'])
amount = decimal_to_cents(currency, amount_dec)
enrolled_amount_dec = cents_to_decimal(currency, amount)
if amount < 0:
amount *= -1
trans_data = {'environment_id': session.environment_id,
'user_id': balance.user_id, 'balance_id': balance.id,
'currency_code': currency.code, 'real_amount': 0, 'virtual_amount': 0,
'type': transaction_type, 'info': data.get('info', {})}
if transaction_type == 'receipt':
balance.real_amount += amount
trans_data['real_amount'] = enrolled_amount_dec
elif transaction_type == 'bonus':
balance.virtual_amount += amount
trans_data['virtual_amount'] = enrolled_amount_dec
else:
raise HelixbillingError('Unhandled income transaction type: %s' %
transaction_type)
mapping.update(curs, balance)
trans = Transaction(**trans_data)
mapping.insert(curs, trans)
return trans.id
def add_tariffication_object(self, data, session, curs=None):
name = data['name']
to_data = {'environment_id': session.environment_id, 'name': name}
to = TarifficationObject(**to_data)
try:
mapping.insert(curs, to)
except ObjectCreationError:
raise TarifficationObjectAlreadyExsits(name)
return response_ok(id=to.id)
def add_tariffication_object(self, data, session, curs=None):
name = data['name']
to_data = {'environment_id': session.environment_id,
'name': name}
to = TarifficationObject(**to_data)
try:
mapping.insert(curs, to)
except ObjectCreationError:
raise TarifficationObjectAlreadyExsits(name)
return response_ok(id=to.id)
def lock(self, data, session, curs=None):
balance = self._get_active_balance(session, curs, data)
currs_id_idx = self._get_currs_idx(curs, 'id')
currency = currs_id_idx[balance.currency_id]
lock_amount_dec = Decimal(data['amount'])
lock_amount = decimal_to_cents(currency, lock_amount_dec)
if lock_amount < 0:
lock_amount *= -1
locking_order = data['locking_order']
amounts_to_lock = compute_locks(balance, lock_amount, locking_order)
lock_real = amounts_to_lock.get('real_amount', 0)
lock_virtual = amounts_to_lock.get('virtual_amount', 0)
order_id = data['order_id']
info = data.get('info', {})
info['locking_order'] = locking_order
trans_data = {
'environment_id': session.environment_id,
'user_id': balance.user_id,
'balance_id': balance.id,
'currency_code': currency.code,
'type': 'lock',
'real_amount': cents_to_decimal(currency, lock_real),
'virtual_amount': cents_to_decimal(currency, lock_virtual),
'order_id': order_id,
'info': info
}
lock_data = {
'environment_id': session.environment_id,
'user_id': balance.user_id,
'balance_id': balance.id,
'real_amount': lock_real,
'locking_order': locking_order,
'order_id': order_id,
'currency_id': currency.id,
'virtual_amount': lock_virtual,
'info': info
}
lock = BalanceLock(**lock_data)
balance.real_amount -= lock_real
balance.virtual_amount -= lock_virtual
balance.locked_amount += lock_real + lock_virtual
mapping.update(curs, balance)
trans = Transaction(**trans_data)
mapping.insert(curs, lock)
mapping.insert(curs, trans)
return response_ok(transaction_id=trans.id, lock_id=lock.id)
def add_tariff_viewing_context(self, data, session, curs=None):
# checking parent tariff exist
t_id = data['tariff_id']
t_f = TariffFilter(session, {'id': t_id}, {}, None)
t_f.filter_one_obj(curs)
raw_ctx = data['context']
ctx = self._collapse_context(raw_ctx)
t_v_data = {'environment_id': session.environment_id,
'tariff_id': t_id, 'name': data['name'],
'view_order': data['view_order'], 'context': ctx}
t_v_ctx = TariffViewingContext(**t_v_data)
mapping.insert(curs, t_v_ctx)
return response_ok(id=t_v_ctx.id)
def add_user_tariff(self, data, session, curs=None):
# checking tariff exist
t_id = data['tariff_id']
u_id = data['user_id']
if t_id:
t_f = TariffFilter(session, {'id': t_id}, {}, None)
t_f.filter_one_obj(curs)
ut_data = {'environment_id': session.environment_id,
'tariff_id': t_id, 'user_id': u_id}
ut = UserTariff(**ut_data)
try:
mapping.insert(curs, ut)
except ObjectCreationError:
raise UserTariffAlreadyExsits(tariff_id=t_id, user_id=u_id)
return response_ok(id=ut.id)
def add_tariff_viewing_context(self, data, session, curs=None):
# checking parent tariff exist
t_id = data['tariff_id']
t_f = TariffFilter(session, {'id': t_id}, {}, None)
t_f.filter_one_obj(curs)
raw_ctx = data['context']
ctx = self._collapse_context(raw_ctx)
t_v_data = {
'environment_id': session.environment_id,
'tariff_id': t_id,
'name': data['name'],
'view_order': data['view_order'],
'context': ctx
}
t_v_ctx = TariffViewingContext(**t_v_data)
mapping.insert(curs, t_v_ctx)
return response_ok(id=t_v_ctx.id)
def add_user_tariff(self, data, session, curs=None):
# checking tariff exist
t_id = data['tariff_id']
u_id = data['user_id']
if t_id:
t_f = TariffFilter(session, {'id': t_id}, {}, None)
t_f.filter_one_obj(curs)
ut_data = {
'environment_id': session.environment_id,
'tariff_id': t_id,
'user_id': u_id
}
ut = UserTariff(**ut_data)
try:
mapping.insert(curs, ut)
except ObjectCreationError:
raise UserTariffAlreadyExsits(tariff_id=t_id, user_id=u_id)
return response_ok(id=ut.id)
def lock(self, data, session, curs=None):
balance = self._get_active_balance(session, curs, data)
currs_id_idx = self._get_currs_idx(curs, 'id')
currency = currs_id_idx[balance.currency_id]
lock_amount_dec = Decimal(data['amount'])
lock_amount = decimal_to_cents(currency, lock_amount_dec)
if lock_amount < 0:
lock_amount *= -1
locking_order = data['locking_order']
amounts_to_lock = compute_locks(balance, lock_amount, locking_order)
lock_real = amounts_to_lock.get('real_amount', 0)
lock_virtual = amounts_to_lock.get('virtual_amount', 0)
order_id = data['order_id']
info = data.get('info', {})
info['locking_order'] = locking_order
trans_data = {'environment_id': session.environment_id, 'user_id': balance.user_id,
'balance_id': balance.id, 'currency_code': currency.code,
'type': 'lock', 'real_amount': cents_to_decimal(currency, lock_real),
'virtual_amount': cents_to_decimal(currency, lock_virtual),
'order_id': order_id, 'info': info}
lock_data = {'environment_id': session.environment_id, 'user_id': balance.user_id,
'balance_id': balance.id, 'real_amount': lock_real, 'locking_order': locking_order,
'order_id': order_id, 'currency_id': currency.id, 'virtual_amount': lock_virtual,
'info': info}
lock = BalanceLock(**lock_data)
balance.real_amount -= lock_real
balance.virtual_amount -= lock_virtual
balance.locked_amount += lock_real + lock_virtual
mapping.update(curs, balance)
trans = Transaction(**trans_data)
mapping.insert(curs, lock)
mapping.insert(curs, trans)
return response_ok(transaction_id=trans.id, lock_id=lock.id)
def _make_income_transaction(self, curs, data, session, transaction_type):
balance = self._get_active_balance(session, curs, data)
currs_id_idx = self._get_currs_idx(curs, 'id')
currency = currs_id_idx[balance.currency_id]
amount_dec = Decimal(data['amount'])
amount = decimal_to_cents(currency, amount_dec)
enrolled_amount_dec = cents_to_decimal(currency, amount)
if amount < 0:
amount *= -1
trans_data = {
'environment_id': session.environment_id,
'user_id': balance.user_id,
'balance_id': balance.id,
'currency_code': currency.code,
'real_amount': 0,
'virtual_amount': 0,
'type': transaction_type,
'info': data.get('info', {})
}
if transaction_type == 'receipt':
balance.real_amount += amount
trans_data['real_amount'] = enrolled_amount_dec
elif transaction_type == 'bonus':
balance.virtual_amount += amount
trans_data['virtual_amount'] = enrolled_amount_dec
else:
raise HelixbillingError('Unhandled income transaction type: %s' %
transaction_type)
mapping.update(curs, balance)
trans = Transaction(**trans_data)
mapping.insert(curs, trans)
return trans.id
def track_api_call(self, remote_addr, s_req, s_resp,
action_name, processed_data, curs=None):
super(HelixauthApplication, self).track_api_call(remote_addr, s_req, s_resp,
action_name, processed_data)
actor_user_id = processed_data.get('actor_user_id')
custom_actor_info = processed_data.get('custom_actor_info')
environment_id = processed_data.get('environment_id')
users_ids = processed_data.get('subject_users_ids', [])
session_id = processed_data.get('session_id')
data = {
'environment_id': environment_id,
'session_id': session_id,
'custom_actor_info': custom_actor_info,
'actor_user_id': actor_user_id,
'subject_users_ids': users_ids,
'action': action_name,
'remote_addr': remote_addr,
'request': s_req,
'response': s_resp,
}
mapping.insert(curs, ActionLog(**data))
def add_balance(self, data, session, curs=None):
user_id = data['user_id']
check_user_exist = data.get('check_user_exist', False)
if check_user_exist:
self._check_user_exist(session, user_id)
currs_code_idx = self._get_currs_idx(curs, 'code')
curr_code = data['currency_code']
if curr_code not in currs_code_idx:
raise CurrencyNotFound(currency_code=curr_code)
curr = currs_code_idx[curr_code]
try:
u_curr_f = UsedCurrencyFilter(session, {}, {}, None)
u_currs = u_curr_f.filter_one_obj(curs)
u_currs_ids = u_currs.currencies_ids
except ObjectNotFound:
u_currs_ids = []
if curr.id not in u_currs_ids:
raise UsedCurrencyNotFound(currency_code=curr_code)
b_data = dict(data)
b_data.pop('currency_code', None)
b_data.pop('session_id', None)
b_data.pop('check_user_exist', None)
b_data.pop('subject_users_ids', None)
b_data['environment_id'] = session.environment_id
b_data['currency_id'] = curr.id
amount_fields = ['overdraft_limit']
balance = Balance(
**decimal_texts_to_cents(b_data, curr, amount_fields))
try:
mapping.insert(curs, balance)
except ObjectCreationError:
raise BalanceAlreadyExists()
return response_ok(id=balance.id)
def add_balance(self, data, session, curs=None):
user_id = data['user_id']
check_user_exist = data.get('check_user_exist', False)
if check_user_exist:
self._check_user_exist(session, user_id)
currs_code_idx = self._get_currs_idx(curs, 'code')
curr_code = data['currency_code']
if curr_code not in currs_code_idx:
raise CurrencyNotFound(currency_code=curr_code)
curr = currs_code_idx[curr_code]
try:
u_curr_f = UsedCurrencyFilter(session, {}, {}, None)
u_currs = u_curr_f.filter_one_obj(curs)
u_currs_ids = u_currs.currencies_ids
except ObjectNotFound:
u_currs_ids = []
if curr.id not in u_currs_ids:
raise UsedCurrencyNotFound(currency_code=curr_code)
b_data = dict(data)
b_data.pop('currency_code', None)
b_data.pop('session_id', None)
b_data.pop('check_user_exist', None)
b_data.pop('subject_users_ids', None)
b_data['environment_id'] = session.environment_id
b_data['currency_id'] = curr.id
amount_fields = ['overdraft_limit']
balance = Balance(**decimal_texts_to_cents(b_data, curr, amount_fields))
try:
mapping.insert(curs, balance)
except ObjectCreationError:
raise BalanceAlreadyExists()
return response_ok(id=balance.id)
def add_tariff(self, data, session, curs=None):
# checking parent tariff exist
pt_id = data['parent_tariff_id']
currency = data.get('currency', None)
t_data = {'environment_id': session.environment_id,
'parent_tariff_id': pt_id, 'name': data['name'],
'type': data['type'], 'status': data['status']}
if pt_id is not None:
if currency is not None:
raise NonParentTariffWithCurrency
else:
t_f = TariffFilter(session, {'id': pt_id}, {}, None)
t_f.filter_one_obj(curs)
elif currency is None:
raise ParentTariffWithoutCurrency
else:
c_f = CurrencyFilter({'code': currency}, {}, None)
c = c_f.filter_one_obj(curs)
t_data['currency_id'] = c.id
t = Tariff(**t_data)
mapping.insert(curs, t)
return response_ok(id=t.id)
def test_insert(self, curs=None):
obj = self.T(name='boh0', client_ids=[4,6,4])
mapping.insert(curs, obj)
