예제 #1
0
def createTestingAccounts(
    session,
    count,
    name_pattern='test%s',
    email_pattern='*****@*****.**',
    password='******',
):
    """Creating many testing accounts

    """
    from nowin_core.models.user import UserModel
    user_model = UserModel(session)
    users = []
    for i in xrange(count):
        name = name_pattern % i
        email = email_pattern % i
        user = user_model.get_user_by_name(name)
        if user is not None:
            print 'user %s already exist, skip'
            continue
        user_id = user_model.create_user(user_name=name,
                                         email=email,
                                         display_name=name,
                                         password=password)
        user_model.activate_user(user_id, name, 'TW')
        users.append(user_id)
        session.flush()
        print 'create user', name
    session.commit()
    return users
예제 #2
0
    def add_blocked_user(self, owner_id, target_id):
        """Add an user to blocked list in a chat-room as a list

        owner_id is the id of chat-room owner, and target_id is the target user
        to block

        """
        if owner_id == target_id:
            raise SelfBlockError("Self-blocking is not allowed")

        radio = self.session.query(tables.Site) \
            .filter_by(user_id=owner_id) \
            .first()
        if radio is None:
            raise NotExistError('Radio %s does not exist' % owner_id)

        user_model = UserModel(self.session)
        target_user = user_model.get_user_by_id(target_id)
        if target_user is None:
            raise NotExistError('Target user %s does not exist' % target_user)

        blocking = self.get_blocking(owner_id, target_id)
        if blocking is not None:
            raise DuplicateError('Duplicate block from %s to %s' %
                                 (owner_id, target_id))

        blocking = tables.Blocking(owner_id=owner_id, target_id=target_id)
        self.session.add(blocking)
        self.session.flush()
예제 #3
0
    def check_permission(self, owner_id, guest_id):
        """Check can an user with guest_id access chat-room of
        user with owner_id?

        if the guest is joining anonymously, then the guest_id should be None
        """
        # TODO: check is the guest an administrator
        settings = self.get_settings(owner_id)
        acl = settings['acl']
        if acl == self.ACL_CLOSED:
            return False
        if acl == self.ACL_MEMBER:
            if guest_id is None:
                return False
            # make sure the guest user is activated
            user_model = UserModel(self.session)
            user = user_model.get_user_by_id(guest_id)
            if not user.active:
                return False
        blocking = self.get_blocking(owner_id, guest_id)
        return blocking is None
예제 #4
0
    def run(self):
        engine = setup_db(uri=self.uri, echo=True)

        from nowin_core.database.tables import DeclarativeBase
        DeclarativeBase.metadata.create_all(bind=engine)

        import getpass
        import transaction
        from ..database import tables
        from ..models.user import UserModel
        from ..models.group import GroupModel
        from ..models.permission import PermissionModel

        session = tables.DBSession

        from zope.sqlalchemy import ZopeTransactionExtension
        session.configure(extension=ZopeTransactionExtension())

        user_model = UserModel(session)
        group_model = GroupModel(session)
        permission_model = PermissionModel(session)

        with transaction.manager:
            admin = user_model.get_user_by_name('admin')
            if admin is None:
                print 'Create admin account'

                email = raw_input('Email:')

                password = getpass.getpass('Password:'******'Confirm:')
                if password != confirm:
                    print 'Password not match'
                    return

                user_id = user_model.create_user(
                    user_name='admin',
                    display_name='Administrator',
                    email=email,
                    password=password
                )
                user_model.activate_user(user_id, '', 'TW')
                admin = user_model.get_user_by_id(user_id)
                session.flush()
                print 'Created admin, user_id=%s' % admin.user_id

            permission = permission_model.get_permission_by_name('admin')
            if permission is None:
                print 'Create admin permission ...'
                permission_model.create_permission(
                    permission_name='admin',
                    description='Administrate',
                )
                permission = permission_model.get_permission_by_name('admin')

            group = group_model.get_group_by_name('admin')
            if group is None:
                print 'Create admin group ...'
                group_model.create_group(
                    group_name='admin',
                    display_name='Administrators',
                )
                group = group_model.get_group_by_name('admin')

            print 'Add admin permission to admin group'
            group_model.update_permissions(
                group.group_id, [permission.permission_id])
            session.flush()

            print 'Add admin to admin group'
            user_model.update_groups(admin.user_id, [group.group_id])
            session.flush()

        print 'Done.'