Exemplo n.º 1
0
    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)
Exemplo n.º 2
0
 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)
Exemplo n.º 3
0
    def test_delete_group(self, curs=None):
        sess_id = self.login_actor()
        groups_num = self._groups_num(sess_id)

        req = {'session_id': sess_id, 'name': 'grp0',
            'rights': [{'service_id': 1, 'properties':['a']}]}
        resp = self.add_group(**req)
        self.check_response_ok(resp)

        req = {'session_id': sess_id, 'name': 'grp1',
            'rights': [{'service_id': 1, 'properties':['a']}]}
        resp = self.add_group(**req)
        self.check_response_ok(resp)

        session = self.get_session(sess_id)
        f = GroupFilter(session.environment_id, {}, {}, None)
        self.assertEquals(groups_num + 2, f.filter_objs_count(curs))

        req = {'session_id': sess_id, 'id': 1}
        resp = self.delete_group(**req)
        self.check_response_ok(resp)
        self.assertEquals(groups_num + 1, f.filter_objs_count(curs))
Exemplo n.º 4
0
 def _get_user_rights(self, curs, env, user, srvs):
     rights = {}
     if user.role != User.ROLE_SUPER:
         f = GroupFilter(env.id, {'ids': user.groups_ids, 'is_active': True},
             {}, None)
         groups = f.filter_objs(curs)
         for g in groups:
             rights_lst = json.loads(g.serialized_rights)
             for r in rights_lst:
                 # String key id for json.encode
                 srv_id = str(r['service_id'])
                 srv_props = r['properties']
                 cur_props = rights.get(srv_id, [])
                 rights[srv_id] = list(set(cur_props + srv_props))
     res = {}
     for srv in srvs:
         if user.role == User.ROLE_SUPER:
             r = json.loads(srv.serialized_properties)
         else:
             r = rights.get(str(srv.id), []) # String key id for json.encode
         res[srv.type] = r
     return res
Exemplo n.º 5
0
 def delete_group(self, data, req_info, session, curs=None):
     f = GroupFilter(session.environment_id, {'id': data.get('id')}, {}, None)
     mapping.delete(curs, f.filter_one_obj(curs))
     return response_ok()
Exemplo n.º 6
0
 def _filter_existed_groups(self, curs, session, groups_ids):
     f = GroupFilter(session.environment_id, {}, {}, None)
     groups = f.filter_objs(curs)
     g_ids = [g.id for g in groups]
     return filter(lambda x: x in g_ids, groups_ids)