def check_access(self, data, req_info, session, curs=None):
a = Authenticator()
srv_type = data.get('service_type', None)
p = data.get('property', None)
try:
a.check_access(session, srv_type, p, req_info)
return response_ok(user_id=session.user_id,
environment_id=session.environment_id, access='granted')
except (UserAccessDenied, SessionIpChanged):
return response_ok(user_id=session.user_id,
environment_id=session.environment_id, access='denied')
def delete_service(self, data, req_info, session, curs=None):
f = ServiceFilter(session.environment_id, {'id': data.get('id')}, {}, None)
s = f.filter_one_obj(curs)
if s.type == Service.TYPE_AUTH:
raise ServiceDeletionError(Service.TYPE_AUTH)
mapping.delete(curs, s)
return response_ok()
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 modify_balances(self, data, session, curs=None):
balances_ids = data['ids']
currency_f = CurrencyFilter({}, {}, None)
currencies = currency_f.filter_objs(curs)
currencies_id_idx = build_index(currencies, 'id')
balance_f = BalanceFilter(session, {'ids': balances_ids}, {}, None)
balances = balance_f.filter_objs(curs)
# Setting users ids for logging
users_ids = [balance.user_id for balance in balances]
data['users_ids'] = users_ids
# Handling different currencies for different balances
new_overdraft_limit = data.pop('new_overdraft_limit', None)
def loader():
if new_overdraft_limit is not None:
for b in balances:
d = {'new_overdraft_limit': new_overdraft_limit}
amount_fields = ['new_overdraft_limit']
currency = currencies_id_idx[b.currency_id]
d = decimal_texts_to_cents(d, currency, amount_fields)
b.overdraft_limit = d['new_overdraft_limit']
return balances
self.update_objs(curs, data, loader)
return response_ok()
def delete_tariff(self, data, session, curs=None):
f = TariffFilter(session, {'id': data['id']}, {}, None)
try:
mapping.delete(curs, f.filter_one_obj(curs))
except ObjectDeletionError:
raise TariffUsed('Tariff %s used' % data['id'])
return response_ok()
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 get_rules(self, data, session, curs=None):
r_f = RuleFilter(session, data['filter_params'], data['paging_params'],
data.get('ordering_params'))
rs, total = r_f.filter_counted(curs)
if total:
all_to_f = TarifficationObjectFilter(session, {}, {}, None)
all_tos = all_to_f.filter_objs(curs)
all_tos_idx = build_index(all_tos)
all_ts_f = TariffFilter(session, {}, {}, None)
all_ts = all_ts_f.filter_objs(curs)
all_ts_idx = build_index(all_ts)
else:
all_tos_idx = {}
all_ts_idx = {}
def viewer(r):
t = all_ts_idx[r.tariff_id]
to = all_tos_idx[r.tariffication_object_id]
return {
'id': r.id,
'tariff_id': t.id,
'tariff_name': t.name,
'tariffication_object_id': to.id,
'tariffication_object_name': to.name,
'status': r.status,
'rule': r.rule,
'draft_rule': r.draft_rule,
'view_order': r.view_order
}
return response_ok(rules=self.objects_info(rs, viewer), total=total)
def delete_user_tariffs(self, data, session, curs=None):
f = UserTariffFilter(session, {
'user_id': data['user_id'],
'tariff_ids': data['tariff_ids']
}, {}, ['id'])
mapping.delete_objects(curs, f.filter_objs(curs, for_update=True))
return response_ok()
def delete_tariff(self, data, session, curs=None):
f = TariffFilter(session, {'id': data['id']}, {}, None)
try:
mapping.delete(curs, f.filter_one_obj(curs))
except ObjectDeletionError:
raise TariffUsed('Tariff %s used' % data['id'])
return response_ok()
def _get_balances(self, curs, balance_f):
balances, total = balance_f.filter_counted(curs)
currs_id_idx = self._get_currs_idx(curs, 'id')
def viewer(balance):
currency = currs_id_idx[balance.currency_id]
return {
'id':
balance.id,
'user_id':
balance.user_id,
'is_active':
balance.is_active,
'currency_code':
currency.code,
'real_amount':
'%s' % cents_to_decimal(currency, balance.real_amount),
'virtual_amount':
'%s' % cents_to_decimal(currency, balance.virtual_amount),
'overdraft_limit':
'%s' % cents_to_decimal(currency, balance.overdraft_limit),
'locked_amount':
'%s' % cents_to_decimal(currency, balance.locked_amount),
}
return response_ok(balances=self.objects_info(balances, viewer),
total=total)
def modify_balances(self, data, session, curs=None):
balances_ids = data['ids']
currency_f = CurrencyFilter({}, {}, None)
currencies = currency_f.filter_objs(curs)
currencies_id_idx = build_index(currencies, 'id')
balance_f = BalanceFilter(session, {'ids': balances_ids}, {}, None)
balances = balance_f.filter_objs(curs)
# Setting users ids for logging
users_ids = [balance.user_id for balance in balances]
data['users_ids'] = users_ids
# Handling different currencies for different balances
new_overdraft_limit = data.pop('new_overdraft_limit', None)
def loader():
if new_overdraft_limit is not None:
for b in balances:
d = {'new_overdraft_limit': new_overdraft_limit}
amount_fields = ['new_overdraft_limit']
currency = currencies_id_idx[b.currency_id]
d = decimal_texts_to_cents(d, currency, amount_fields)
b.overdraft_limit = d['new_overdraft_limit']
return balances
self.update_objs(curs, data, loader)
return response_ok()
def register_user(self, data, req_info, curs=None):
env_name = data.get('environment_name')
env_f = EnvironmentFilter({'name': env_name}, {}, None)
env = env_f.filter_one_obj(curs)
# creating user
a = Authenticator()
salt = a.salt()
lang = data.get('lang', User.DEFAULT_LANG)
u_data = {'environment_id': env.id, 'email': data.get('email'),
'password': a.encrypt_password(data.get('password'), salt),
'salt': salt, 'role': User.ROLE_USER,
'lang': lang}
group_f = GroupFilter(env.id, {'is_default': True}, {}, None)
groups = group_f.filter_objs(curs)
groups_ids = [g.id for g in groups]
u_data['groups_ids'] = groups_ids
user = User(**u_data)
# For correct action logging
data['environment_id'] = env.id
try:
mapping.save(curs, user)
except ObjectCreationError:
raise UserAlreadyExists
auth = Authenticator()
session = auth.create_session(curs, env, user, req_info)
_add_log_info(data, session)
n = Notifier()
n_process = n.register_user(curs, user, session)
return response_ok(session_id=session.session_id, id=user.id,
notification=n_process)
def add_user(self, data, req_info, session, curs=None):
a = Authenticator()
env_id = session.environment_id
salt = a.salt()
u_data = {'environment_id': env_id, 'email': data.get('email'),
'role': data.get('role', User.ROLE_USER),
'password': a.encrypt_password(data.get('password'), salt),
'salt': salt, 'is_active': data.get('is_active', True),
'lang': data.get('lang', User.DEFAULT_LANG)
}
if u_data['role'] == User.ROLE_SUPER:
raise SuperUserCreationDenied
groups_ids = data.get('groups_ids', [])
filtered_g_ids = self._filter_existed_groups(curs, session, groups_ids)
u_data['groups_ids'] = filtered_g_ids
user = User(**u_data)
try:
mapping.save(curs, user)
except ObjectCreationError:
raise HelixauthObjectAlreadyExists
# For correct action logging
data['id'] = [user.id]
n = Notifier()
n_process = n.register_user(curs, user, session)
return response_ok(id=user.id, notification=n_process)
def add_environment(self, data, req_info, curs=None):
env_data = {'name': data.get('name')}
env = Environment(**env_data)
try:
mapping.save(curs, env)
except ObjectCreationError:
raise HelixauthObjectAlreadyExists('Environment %s already exists' % env.name)
# creating user
a = Authenticator()
salt = a.salt()
u_data = {'environment_id': env.id, 'email': data.get('su_email'),
'password': a.encrypt_password(data.get('su_password'), salt),
'salt': salt, 'role': User.ROLE_SUPER,
'lang': User.DEFAULT_LANG}
user = User(**u_data)
mapping.save(curs, user)
# creating default services and groups
self._create_default_objects(req_info, curs, env)
# creating session for super user
auth = Authenticator()
session = auth.create_session(curs, env, user, req_info)
_add_log_info(data, session)
return response_ok(session_id=session.session_id,
environment_id=env.id, user_id=session.user_id)
def login(self, data, req_info, curs=None):
f = EnvironmentFilter(data, {}, None)
env = f.filter_one_obj(curs)
# Required for proper logging action
data['environment_id'] = env.id
f_params = {'environment_id': env.id, 'email': data.get('email')}
f = SubjectUserFilter(env.id, f_params, {}, None)
try:
user = f.filter_one_obj(curs)
except UserNotFound:
raise UserAuthError
if not user.is_active:
raise UserInactive()
# checking password
auth = Authenticator()
enc_p = auth.encrypt_password(data.get('password'), user.salt)
if enc_p != user.password:
raise UserAuthError
# creating session
bind_to_ip = data.get('bind_to_ip', False)
lt_minutes = data.get('fixed_lifetime_minutes')
session = auth.create_session(curs, env, user, req_info,
bind_to_ip=bind_to_ip, lifetime_minutes=lt_minutes)
_add_log_info(data, session)
return response_ok(session_id=session.session_id,
user_id=session.user_id, environment_id=session.environment_id)
def _get_balance_locks(self, curs, lock_f):
locks, total = lock_f.filter_counted(curs)
currs_id_idx = self._get_currs_idx(curs, 'id')
def viewer(lock):
currency = currs_id_idx[lock.currency_id]
lock_info = deserialize_field(lock.to_dict(), 'serialized_info',
'info')
return {
'id':
lock.id,
'user_id':
lock.user_id,
'balance_id':
lock.balance_id,
'currency_code':
currency.code,
'creation_date':
'%s' % lock.creation_date,
'real_amount':
'%s' % cents_to_decimal(currency, lock.real_amount),
'virtual_amount':
'%s' % cents_to_decimal(currency, lock.virtual_amount),
'order_id':
lock.order_id,
'info':
lock_info['info'],
}
return response_ok(locks=self.objects_info(locks, viewer), total=total)
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 add_group(self, data, req_info, session, curs=None):
group = Group(**data)
group.environment_id = session.environment_id
try:
mapping.save(curs, group)
except ObjectCreationError:
raise GroupAlreadyExists('Group %s already exists' % group.name)
return response_ok(id=group.id)
def modify_notifications(self, data, req_info, session, curs=None):
n_ids = data['ids']
f = NotificatonFilter(session.environment_id, {'ids': n_ids},
{}, None)
d = mapping.objects.serialize_field(data, 'new_messages', 'new_serialized_messages')
loader = partial(f.filter_objs, curs, for_update=True)
self.update_objs(curs, d, loader)
return response_ok()
def check_user_exist(self, data, req_info, session, curs=None):
f = UserFilter(session, {'id': data['id']}, {}, None)
exist = False
try:
f.filter_one_obj(curs)
exist = True
except UserNotFound:
pass
return response_ok(exist=exist)
def modify_environment(self, data, req_info, session, curs=None):
f = EnvironmentFilter({'id': session.environment_id}, {}, None)
loader = partial(f.filter_one_obj, curs, for_update=True)
try:
self.update_obj(curs, data, loader)
except DataIntegrityError:
raise HelixauthObjectAlreadyExists('Environment %s already exists' %
data.get('new_name'))
return response_ok()
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 modify_group(self, data, req_info, session, curs=None):
f = GroupFilter(session.environment_id, {'id': data.get('id')}, {}, None)
loader = partial(f.filter_one_obj, curs, for_update=True)
try:
self.update_obj(curs, mapping.objects.serialize_field(data, 'new_rights', 'new_serialized_rights'),
loader)
except DataIntegrityError:
raise GroupAlreadyExists(data.get('new_name'))
return response_ok()
def load_new_notifications(self, data, req_info, session, curs=None):
f = NotificatonFilter(session.environment_id, {}, {}, None)
objs = f.filter_objs(curs, for_update=True)
e_names_cur = [o.event for o in objs]
e_names_to_load = [e_name for e_name in message.EVENTS if e_name not in e_names_cur]
env_f = EnvironmentFilter({'id': session.environment_id}, {}, None)
env = env_f.filter_one_obj(curs)
self._create_default_notifications(curs, env, e_names_to_load)
return response_ok(loaded=len(e_names_to_load))
def modify_tariffication_object(self, data, session, curs=None):
f = TarifficationObjectFilter(session, {'id': data.get('id')}, {}, None)
loader = partial(f.filter_one_obj, curs, for_update=True)
try:
self.update_obj(curs, data, loader)
except DataIntegrityError:
raise HelixtariffObjectAlreadyExists('Tariffication object %s already exists' %
data.get('new_name'))
return response_ok()
def set_password_self(self, data, req_info, session, curs=None):
f = UserFilter(session, {'id': session.user_id}, {}, None)
d = {}
a = Authenticator()
salt = a.salt()
d['new_salt'] = salt
d['new_password'] = a.encrypt_password(data['new_password'], salt)
loader = partial(f.filter_one_obj, curs, for_update=True)
self.update_obj(curs, d, loader)
return response_ok()
def get_tariffication_objects(self, data, session, curs=None):
to_f = TarifficationObjectFilter(session, data['filter_params'],
data['paging_params'], data.get('ordering_params'))
tos, total = to_f.filter_counted(curs)
def viewer(to):
return {
'id': to.id,
'name': to.name,
}
return response_ok(tariffication_objects=self.objects_info(tos, viewer), total=total)
def add_service(self, data, req_info, session, curs=None):
d = dict(data)
d['environment_id'] = session.environment_id
d['is_possible_deactiate'] = True
s = Service(**d)
try:
mapping.save(curs, s)
except ObjectCreationError:
raise HelixauthObjectAlreadyExists
return response_ok(id=s.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 get_user_rights(self, data, req_info, session, curs=None):
s_data = json.loads(session.serialized_data)
s_rights = s_data['rights']
srvs_id_type_idx = s_data['services_id_type_idx']
rights = []
for srv_id in srvs_id_type_idx.keys():
srv_type = srvs_id_type_idx[srv_id]
props = s_rights[srv_type]
rights.append({'service_id': int(srv_id),
'service_type': srv_type, 'properties': props})
return response_ok(rights=rights)
def get_services(self, data, req_info, session, curs=None):
f = ServiceFilter(session.environment_id, data['filter_params'],
data['paging_params'], data.get('ordering_params'))
ss, total = f.filter_counted(curs)
def viewer(obj):
result = obj.to_dict()
result = mapping.objects.deserialize_field(result, 'serialized_properties', 'properties')
result.pop('environment_id')
return result
return response_ok(services=self.objects_info(ss, viewer),
total=total)
def get_used_currencies(self, data, session, curs=None):
f = CurrencyFilter({}, {}, data.get('ordering_params'))
currs = f.filter_objs(curs)
f = UsedCurrencyFilter(session, {}, {}, None)
try:
u_currs = f.filter_one_obj(curs)
u_currs_ids = u_currs.currencies_ids
except ObjectNotFound:
u_currs_ids = []
filtered_currs = [curr for curr in currs if curr.id in u_currs_ids]
return response_ok(currencies=self._currencies_info(filtered_currs))
def get_used_currencies(self, data, session, curs=None):
f = CurrencyFilter({}, {}, data.get('ordering_params'))
currs = f.filter_objs(curs)
f = UsedCurrencyFilter(session, {}, {}, None)
try:
u_currs = f.filter_one_obj(curs)
u_currs_ids = u_currs.currencies_ids
except ObjectNotFound:
u_currs_ids = []
filtered_currs = [curr for curr in currs if curr.id in u_currs_ids]
return response_ok(currencies=self._currencies_info(filtered_currs))
def modify_tariffication_object(self, data, session, curs=None):
f = TarifficationObjectFilter(session, {'id': data.get('id')}, {},
None)
loader = partial(f.filter_one_obj, curs, for_update=True)
try:
self.update_obj(curs, data, loader)
except DataIntegrityError:
raise HelixtariffObjectAlreadyExists(
'Tariffication object %s already exists' %
data.get('new_name'))
return response_ok()
def logout(self, data, req_info, curs=None):
session_id = data.get('session_id')
f = SessionFilter({'session_id': session_id}, {}, None)
try:
session = f.filter_one_obj(curs, for_update=True)
mapping.delete(curs, session)
_add_log_info(data, session)
except SessionNotFound:
pass
return response_ok()
def reset_notifications(self, data, req_info, session, curs=None):
n_ids = data['ids']
f = NotificatonFilter(session.environment_id, {'ids': n_ids},
{}, None)
objs = f.filter_objs(curs, for_update=True)
n = Notifier()
for o in objs:
if o.type == Notification.TYPE_EMAIL:
msg_struct = n.default_email_notif_struct(o.event)
o.serialized_messages = json.dumps(msg_struct)
mapping.save(curs, o)
return response_ok()
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 get_groups(self, data, req_info, session, curs=None):
f = GroupFilter(session.environment_id, data['filter_params'],
data['paging_params'], data.get('ordering_params'))
ss, total = f.filter_counted(curs)
def viewer(obj):
result = obj.to_dict()
result.pop('environment_id', None)
s_rights = result.pop('serialized_rights', '')
result['rights'] = json.loads(s_rights)
return result
return response_ok(groups=self.objects_info(ss, viewer),
total=total)
def get_notifications(self, data, req_info, session, curs=None):
f = NotificatonFilter(session.environment_id,
data['filter_params'], data['paging_params'],
data.get('ordering_params'))
notifs, total = f.filter_counted(curs)
def viewer(obj):
result = obj.to_dict()
result.pop('environment_id')
result = mapping.objects.deserialize_field(result,
'serialized_messages', 'messages')
return result
return response_ok(notifications=self.objects_info(notifs, viewer), total=total)
def get_user_tariffs(self, data, session, curs=None):
ut_f = UserTariffFilter(session, data['filter_params'],
data['paging_params'], data.get('ordering_params'))
uts = ut_f.filter_objs(curs)
uts_data = {}
for ut in uts:
if ut.user_id not in uts_data:
uts_data[ut.user_id] = []
uts_data[ut.user_id].append(ut.tariff_id)
uts_info = [{'user_id': k, 'tariff_ids': v} for k, v in uts_data.items()]
uts_info.sort(key=lambda x: x['user_id'])
return response_ok(user_tariffs=uts_info, total=len(uts_info))
def get_tariff_viewing_contexts(self, data, session, curs=None):
ordering_params = data.get('ordering_params', ['view_order'])
t_f = TariffViewingContextFilter(session, data['filter_params'],
data['paging_params'], ordering_params)
ts, total = t_f.filter_counted(curs)
def viewer(t_v_ctx):
res = t_v_ctx.to_dict()
res = mapping.objects.deserialize_field(res, 'serialized_context', 'context')
res['context'] = self._expand_context(res['context'])
res.pop('environment_id')
return res
return response_ok(tariff_contexts=self.objects_info(ts, viewer), total=total)
def apply_draft_rules(self, data, session, curs=None):
t_f = TariffFilter(session, {'id': data['tariff_id']}, {}, None)
t_f.filter_one_obj(curs)
f = RuleFilter(session, {'tariff_id': data['tariff_id']}, {}, ['id'])
rs = f.filter_objs(curs, for_update=True)
checker = RuleChecker()
for r in rs:
if r.draft_rule:
checker.check(r.draft_rule)
r.rule = r.draft_rule
r.draft_rule = None
mapping.update(curs, r)
return response_ok()
def _get_transactions(self, data, session, curs):
f = TransactionsFilter(session.environment_id, data['filter_params'],
data['paging_params'], data.get('ordering_params'))
transactions, total = f.filter_counted(curs)
def viewer(trn):
result = deserialize_field(trn.to_dict(), 'serialized_info', 'info')
result.pop('environment_id', None)
result['creation_date'] = '%s' % result['creation_date']
result['real_amount'] = '%s' % trn.real_amount
result['virtual_amount'] = '%s' % trn.virtual_amount
result['order_id'] = trn.order_id
return result
return response_ok(transactions=self.objects_info(transactions, viewer),
total=total)
def get_tariffication_objects(self, data, session, curs=None):
to_f = TarifficationObjectFilter(session, data['filter_params'],
data['paging_params'],
data.get('ordering_params'))
tos, total = to_f.filter_counted(curs)
def viewer(to):
return {
'id': to.id,
'name': to.name,
}
return response_ok(tariffication_objects=self.objects_info(
tos, viewer),
total=total)
def _get_action_logs(self, data, session, curs):
f_params = data['filter_params']
u_id = f_params.pop('user_id', None)
if u_id:
f_params[('subject_users_ids', 'actor_user_id')] = (u_id, u_id)
f = ActionLogFilter(session.environment_id, f_params,
data['paging_params'], data.get('ordering_params'))
action_logs, total = f.filter_counted(curs)
def viewer(obj):
result = obj.to_dict()
result.pop('environment_id', None)
result['request_date'] = '%s' % result['request_date']
return result
return response_ok(action_logs=self.objects_info(action_logs, viewer),
total=total)
def modify_tariff_viewing_context(self, data, session, curs=None):
f = TariffViewingContextFilter(session, {'id': data.get('id')}, {},
None)
loader = partial(f.filter_one_obj, curs, for_update=True)
if 'new_tariff_id' in data:
t_id = data.get('new_tariff_id')
t_f = TariffFilter(session, {'id': t_id}, {}, None)
t_f.filter_one_obj(curs)
if 'new_context' in data:
data['new_context'] = self._collapse_context(data['new_context'])
data = mapping.objects.serialize_field(data, 'new_context',
'new_serialized_context')
self.update_obj(curs, data, loader)
return response_ok()
def get_user_tariffs(self, data, session, curs=None):
ut_f = UserTariffFilter(session, data['filter_params'],
data['paging_params'],
data.get('ordering_params'))
uts = ut_f.filter_objs(curs)
uts_data = {}
for ut in uts:
if ut.user_id not in uts_data:
uts_data[ut.user_id] = []
uts_data[ut.user_id].append(ut.tariff_id)
uts_info = [{
'user_id': k,
'tariff_ids': v
} for k, v in uts_data.items()]
uts_info.sort(key=lambda x: x['user_id'])
return response_ok(user_tariffs=uts_info, total=len(uts_info))
def get_tariff_viewing_contexts(self, data, session, curs=None):
ordering_params = data.get('ordering_params', ['view_order'])
t_f = TariffViewingContextFilter(session, data['filter_params'],
data['paging_params'],
ordering_params)
ts, total = t_f.filter_counted(curs)
def viewer(t_v_ctx):
res = t_v_ctx.to_dict()
res = mapping.objects.deserialize_field(res, 'serialized_context',
'context')
res['context'] = self._expand_context(res['context'])
res.pop('environment_id')
return res
return response_ok(tariff_contexts=self.objects_info(ts, viewer),
total=total)
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 _get_transactions(self, data, session, curs):
f = TransactionsFilter(session.environment_id, data['filter_params'],
data['paging_params'],
data.get('ordering_params'))
transactions, total = f.filter_counted(curs)
def viewer(trn):
result = deserialize_field(trn.to_dict(), 'serialized_info',
'info')
result.pop('environment_id', None)
result['creation_date'] = '%s' % result['creation_date']
result['real_amount'] = '%s' % trn.real_amount
result['virtual_amount'] = '%s' % trn.virtual_amount
result['order_id'] = trn.order_id
return result
return response_ok(transactions=self.objects_info(
transactions, viewer),
total=total)
def get_tariffs_prices(self, data, session, curs=None):
f_params = data['filter_params']
if 'user_id' in f_params:
user_id = f_params['user_id']
ts_ids = f_params['ids']
ut_f = UserTariffFilter(session, {
'user_id': user_id,
'tariff_ids': ts_ids
}, {}, None)
uts = ut_f.filter_objs(curs)
uts_tariff_ids = [ut.tariff_id for ut in uts]
ts_ids = filter(lambda x: x in uts_tariff_ids, ts_ids)
f_params['ids'] = ts_ids
t_f = TariffFilter(session, data['filter_params'],
data['paging_params'], data.get('ordering_params'))
ts, total = t_f.filter_counted(curs)
ts_idx = build_index(ts)
ts_ids = filter(lambda x: x in ts_idx, data['filter_params']['ids'])
all_tos_f = TarifficationObjectFilter(session, {}, {}, None)
all_tos = all_tos_f.filter_objs(curs)
all_tos_idx = build_index(all_tos)
all_ts_f = TariffFilter(session, {}, {}, None)
all_ts = all_ts_f.filter_objs(curs)
all_ts_idx = build_index(all_ts)
active_r_f = RuleFilter(session, {}, {}, None)
active_rs = active_r_f.filter_objs(curs)
active_rs_to_t_idx = build_complex_index(
active_rs, ('tariffication_object_id', 'tariff_id'))
tariffs_prices = []
calculation_ctxs = data['calculation_contexts']
for t_id in ts_ids:
tariff_price_info = self._tariff_price_info(
session, curs, ts_idx[t_id], all_tos_idx, all_ts_idx,
active_rs_to_t_idx, calculation_ctxs)
tariffs_prices.append(tariff_price_info)
return response_ok(tariffs=tariffs_prices, total=total)
def save_rule(self, data, session, curs=None):
all_t_f = TariffFilter(session, {}, {}, None)
all_ts = all_t_f.filter_objs(curs)
all_ts_idx = build_index(all_ts)
all_to_f = TarifficationObjectFilter(session, {}, {}, None)
all_tos = all_to_f.filter_objs(curs)
all_tos_idx = build_index(all_tos)
all_r_f = RuleFilter(session, {}, {}, None)
all_rs = all_r_f.filter_objs(curs)
all_rs_idx = build_index(all_rs)
r_data = {
'environment_id': session.environment_id,
'tariff_id': data['tariff_id'],
'status': data['status'],
'tariffication_object_id': data['tariffication_object_id'],
'draft_rule': data['draft_rule']
}
r_data['view_order'] = data.get('view_order', 0)
rule_id = data.get('id')
if rule_id:
r_data['id'] = rule_id
r = Rule(**r_data)
if rule_id and rule_id not in all_rs_idx:
raise RuleNotFound(id=rule_id)
if r.tariff_id not in all_ts_idx:
raise TariffNotFound(rule_id=rule_id, tariff_id=r.tariff_id)
if r.tariffication_object_id not in all_tos_idx:
raise TarifficationObjectNotFound(
rule_id=rule_id,
tariffication_object_id=r.tariffication_object_id)
checker = RuleChecker()
checker.check(r.draft_rule)
try:
mapping.save(curs, r)
except ObjectCreationError:
raise RuleAlreadyExsits(r)
return response_ok(id=r.id)
def modify_used_currencies(self, data, session, curs=None):
f = CurrencyFilter({}, {}, None)
currs = f.filter_objs(curs)
currs_code_idx = build_index(currs, idx_field='code')
new_currs_codes = data.pop('new_currencies_codes', [])
for curr_code in new_currs_codes:
if curr_code not in currs_code_idx:
raise CurrencyNotFound(code=curr_code)
new_currs_ids = [
curr.id for curr in currs if curr.code in new_currs_codes
]
data['new_currencies_ids'] = new_currs_ids
f = UsedCurrencyFilter(session, {}, {}, None)
try:
loader = partial(f.filter_one_obj, curs, for_update=True)
self.update_obj(curs, data, loader)
except ObjectNotFound:
u_currs = UsedCurrency(environment_id=session.environment_id,
currencies_ids=new_currs_ids)
mapping.save(curs, u_currs)
return response_ok()
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 modify_tariff(self, data, session, curs=None):
f = TariffFilter(session, {'id': data.get('id')}, {}, None)
loader = partial(f.filter_one_obj, curs, for_update=True)
if 'new_currency' in data:
curr = data.pop('new_currency')
if curr is not None:
c_f = CurrencyFilter({'code': curr}, {}, None)
c = c_f.filter_one_obj(curs)
curr_id = c.id
else:
curr_id = None
data['new_currency_id'] = curr_id
try:
updated_objs = self.update_obj(curs, data, loader)
t = updated_objs[0]
# checking only parent tariff with currency
if t.parent_tariff_id is None and t.currency_id is None:
raise ParentTariffWithoutCurrency
if t.currency_id is not None and t.parent_tariff_id is not None:
raise NonParentTariffWithCurrency
# checking tariff cycle
all_ts_f = TariffFilter(session, {}, {}, None)
all_ts = all_ts_f.filter_objs(curs)
all_ts_idx = build_index(all_ts)
all_curs_idx = self._all_curs_idx(curs)
self._tariffs_chain_data(all_ts_idx, t, all_curs_idx)
except DataIntegrityError:
raise HelixtariffObjectAlreadyExists('Tariff %s already exists' %
data.get('new_name'))
return response_ok()
def ping(self, _):
return response_ok()
def get_draft_price(self, data, session, curs=None):
price_info = self._price_info(session, curs, data, 'draft_rule')
return response_ok(**price_info)
def delete_rule(self, data, session, curs=None):
f = RuleFilter(session, {'id': data['id']}, {}, None)
mapping.delete(curs, f.filter_one_obj(curs))
return response_ok()
def delete_tariff_viewing_context(self, data, session, curs=None):
f = TariffViewingContextFilter(session, {'id': data['id']}, {}, None)
mapping.delete(curs, f.filter_one_obj(curs))
return response_ok()
