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 _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 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 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 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 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()