Python user.User类代码示例

def adduser(dbsession):
    user = User(login='test_forms_user',
                lastname='lastname__éé',
                firstname='firstname__éé')
    user.set_password(u"Tést$!Pass")
    dbsession.add(user)
    dbsession.flush()
    return user

def test_role(dbsession):
    a = User(**TEST1)
    assert a.is_admin()
    assert not a.is_manager()
    a = User(**TEST2)
    assert a.is_manager()
    assert not a.is_admin()
    a = User(**TEST3)
    assert a.is_contractor()
    assert not a.is_admin()

 def test_role(self):
     a = User(**TEST1)
     self.assertTrue(a.is_admin())
     self.assertFalse(a.is_manager())
     a = User(**TEST2)
     self.assertTrue(a.is_manager())
     self.assertFalse(a.is_admin())
     a = User(**TEST3)
     self.assertTrue(a.is_contractor())
     self.assertFalse(a.is_admin())

 def test_account(self):
     a = User(**TEST1)
     a.set_password('pwd')
     self.assertTrue(a.auth("pwd"))
     strange = "#;\'\\\" $25; é ö ô è à ù"
     a.set_password(strange)
     self.assertFalse(a.auth("pwd"))
     self.assertTrue(a.auth(strange))

def add_user(login, password, group, firstname="", lastname=""):
    user = User(login=login, firstname=firstname, lastname=lastname)
    user.set_password(password)

    user.primary_group = group

    session = DBSESSION()
    session.add(user)

    session.flush()

    group_name = GROUPS[group]
    print "Added %s: %s/%s" % (group_name, login, password)

    return user

def get_user_choices():
    """
        Return the a list of values for the contractor autocomplete widget
    """
    choices = [(0, u'Tous les entrepreneurs')]
    choices.extend([(unicode(user.id),
                     u"{0} {1}".format(user.lastname, user.firstname),)
                        for user in User.query().all()])
    return choices

def unique_login(node, value):
    """
        Test login unicity against database
    """
    result = User.query(only_active=False).filter_by(login=value).first()
    if result:
        message = u"Le login '{0}' n'est pas disponible.".format(
                                                            value)
        raise colander.Invalid(node, message)

def test_gen_cancelinvoice_payment(dbsession, invoice):
    user = User.query().first()
    project = Project.query().first()
    invoice.project = project
    invoice.owner = user
    invoice.statusPersonAccount = user
    invoice.record_payment(mode="c", amount=1500)
    cinv = invoice.gen_cancelinvoice(user)
    assert len(cinv.lines) ==  len(invoice.lines) + len(invoice.discounts) + 1
    assert cinv.lines[-1].cost == 1500

 def test_company_index(self):
     avatar = User.get(3)
     self.config.add_route('company', '/company/{cid}')
     self.config.add_static_view('static', 'autonomie:static')
     request = self.get_csrf_request()
     request._user = avatar
     request.user = avatar
     request.context = avatar.companies[0]
     response = company_index(request)
     self.assertEqual(avatar.companies[0].name, response['company'].name )

def test_company_index(config, content, get_csrf_request_with_db):
    from autonomie.views.company import company_index
    avatar = User.query().first()
    config.add_route('company', '/company/{cid}')
    config.add_static_view('static', 'autonomie:static')
    request = get_csrf_request_with_db()
    request._user = avatar
    request.user = avatar
    request.context = avatar.companies[0]
    response = company_index(request)
    assert avatar.companies[0].name == response['company'].name

 def test_gen_cancelinvoice_payment(self):
     user = User.query().first()
     project = Project.query().first()
     inv = self.getOne()
     inv.project = project
     inv.owner = user
     inv.statusPersonAccount = user
     inv.record_payment(mode="c", amount=1500)
     cinv = inv.gen_cancelinvoice(user)
     self.assertEqual(len(cinv.lines),
                       len(inv.lines) + len(inv.discounts) + 1)
     self.assertEqual(cinv.lines[-1].cost, 1500)

def add_admin(arguments, env):
    """
        Add an admin user to the database
    """
    login = get_value(arguments, 'user', 'admin.majerti')
    password = get_value(arguments, 'pwd', get_pwd())
    firstname = get_value(arguments, 'firstname', 'Admin')
    lastname = get_value(arguments, 'lastname', 'Majerti')
    email = get_value(arguments, 'email', '[email protected]')
    user = User(login=login,
                firstname=firstname,
                primary_group=1,  #is an admin
                lastname=lastname,
                email=email
            )
    user.set_password(password)
    db = DBSESSION()
    db.add(user)
    db.flush()
    print u"Creating account %s with password %s" % (login, unicode(password))
    return user

def auth(form, value):
    """
        Check the login/password content
    """
    log.debug(u" * Authenticating")
    login = value.get('login')
    log.debug(u"   +  Login {0}".format(login))
    password = value.get('password')
    result = User.query().filter_by(login=login).first()
    if not result or not result.auth(password):
        log.debug(u"    - Authentication Error")
        message = u"Erreur d'authentification"
        exc = colander.Invalid(form, message)
        exc['password'] = message
        raise exc

def upgrade():
    logger = logging.getLogger("alembic.migrate_code_compta")
    op.add_column("company", sa.Column("code_compta", sa.String(30), default=0))
    dbsession = DBSESSION()
    for user in User.query():
        code_compta = user.code_compta
        companies = user.companies
        if code_compta not in [u"0", None, u""]:
            if len(companies) == 1:
                company = companies[0]
                company.code_compta = code_compta
                dbsession.merge(company)
            else:
                logger.warn(u"User {0} has a code_compta and multiple \
companies".format(user.id))

def test_gen_cancelinvoice(dbsession, invoice):
    user = User.query().first()
    project = Project.query().first()
    invoice.project = project
    invoice.owner = user
    invoice.statusPersonAccount = user
    dbsession.add(invoice)
    dbsession.flush()
    cinv = invoice.gen_cancelinvoice(user)
    dbsession.add(cinv)
    dbsession.flush()

    assert cinv.name == "Avoir 1"
    assert cinv.total_ht() == -1 * invoice.total_ht()
    today = datetime.date.today()
    assert cinv.taskDate == today