def activate_user(activation_code, new_password): """ Entrypoint for activating a user. Also sets their password if Args: activation_code: The activation code used to activate a user. new_password: The password that has to be set for the user Returns: A dictionary {'activated': True} if the user was successfully activated. If no user was found matching the activation code, the value will be False. """ um = logic.UserManager() try: user = um.lookup_user_by_activation_code(activation_code) user.activate() user.set_password(new_password) except ex.UserNotFoundError: blogger.debug("no user found with activation code %s" % activation_code) transaction.abort() return dict(activated=False) else: transaction.commit() return dict(activated=True)
def user_info(client_id, email): """ Returns information about the user and his orders. """ um = logic.UserManager() try: user = um.lookup_user_by_email(email) orders = om.get_orders_of_user(user.id) except ex.TickeeError as e: transaction.abort() return marshalling.error(e) except Exception as e: transaction.abort() return marshalling.internal_error(e) else: result = dict(first_name=user.first_name, last_name=user.last_name, email=user.email, orders=map(lambda o: dict(id=o.id, tickets=map(lambda t: marshalling.ticket_to_dict(t, include_scanned=True, include_user=False), o.get_tickets()), status=o.status, date=marshalling.date(o.session_start)), orders)) return result
def test_lookup_user(self): # Setup um = logic.UserManager() # Test user = um.lookup_user_by_id(self.user.id) # Validate self.assertEqual(user.id, self.user.id, "User id's did not match.")
def test_reset_user(self): # Setup um = logic.UserManager() # Test um.reset_user(self.user.id) # Validate self.assertFalse(self.user.is_active(), "User is active.")
def create_user(email, password): """ Entrypoint for creating new users. Args: email: Personal email address of the user password: Password of the user. Returns: A dictionary containing the information of the newly created user including his identifier. A ``created`` key-value pair is added indicating the success of the attempt. For example: {'created': True, 'user': {"id": 42, "email": "*****@*****.**"}} The dictionary will only contain the created key if the attempt was not successful: {'created': False} """ um = logic.UserManager() try: # validate if email contains actually a valid email address: validate_email(email) # create account user = um.create_user(email) if password: user.set_password(password) else: user.reset() except ex.TickeeError as e: transaction.abort() # build failed result return marshalling.error(e) except ValidationError as e: transaction.abort() return marshalling.error(e) else: user_info = marshalling.user_to_dict(user) transaction.commit() # build success result result = marshalling.created_success_dict.copy() result['user'] = user_info return result
def user_exists(email): """ Entrypoint for checking if a user with a given email already exists. Args: email: The email address that needs to be checked for existence. Returns: A dictionary {'exists': True} if it exists. If there is no user found with the email address, the value will be False. """ um = logic.UserManager() try: user = um.lookup_user_by_email(email) except ex.TickeeError, e: transaction.abort() return dict(exists=False)
def create_account(user_id, account_name, email): """ Entrypoint for creating an account and returning its information back as a dictionary. Args: user_id: Id of the user who will own the account account_name Name of the account to create email Email of the account. This should be a general email address and not a user-specific one. Returns: A dictionary containing the information of the newly created account including its identifier. A ``created`` key-value pair is added indicating the success of the attempt. For example: {'created': True, 'account': {"id": 42, "name": "Tickee", "email": "*****@*****.**"}} The dictionary will only contain the created key if the attempt was not successful: {'created': False} """ am = logic.AccountManager() sm = logic.SecurityManager() try: # find user um = logic.UserManager() user = um.lookup_user_by_id(user_id) # create account account = am.create_account(account_name, email) # create default oauth2 client client = sm.create_oauth_client() account.client_id = client.id except ex.TickeeError, e: transaction.abort() # build failed result return marshalling.error(e)
from tickee import logic from tickee.db.models.event import Event from tickee.db.models.user import User import sqlahelper import tests import tickee.exceptions as ex Session = sqlahelper.get_session() um = logic.UserManager() class CreateUserTest(tests.BaseTestCase): def setUp(self): super(CreateUserTest, self).setUp() def test_create_user(self): # Test user = User("*****@*****.**") # Validate self.assertFalse(user.has_usable_password()) self.assertEquals("*****@*****.**", user.email) self.assertFalse(user.is_active()) def test_activate_user(self): # Prepare user = User("*****@*****.**") activation_key = user.activation_key # Test user.activate(activation_key, "test") # Validate
def test_lookup_unexisting_user(self): # Setup um = logic.UserManager() # Test self.assertRaises(ex.UserNotFoundError, um.lookup_user_by_id, 999)
def test_reset_unexisting_user(self): # Setup um = logic.UserManager() # Test self.assertRaises(ex.UserNotFoundError, um.reset_user, 999)
def setUp(self): super(UserActions, self).setUp() # create user um = logic.UserManager() self.user = um.create_user("") self.user.activate(self.user.activation_key, "")
def test_create_existing_user(self): # Setup um = logic.UserManager() um.create_user("*****@*****.**") # Validate self.assertRaises(ex.UserError, um.create_user, "*****@*****.**")
def test_create_user(self): # Setup um = logic.UserManager() # Test um.create_user("")