def setUp(self):
self.app = app.test_client()
user = User(username='******',
email='*****@*****.**',
job='Test Job',
city='Test City',
name='Test Name',
github='Test github',
twitter='Test twitter',
linkedin='Test linkedin',
facebook='Test facebook',
googleplus='Test googleplus',
foursquare='Test foursquare',
personal_web='Test personal web')
user = user.save()
self.id = user.id
self.username = user.username
def setUp(self):
user = User(username='******',
email='Test email',
job='Test Job',
city='Test City',
name='Test Name',
github='Test github',
twitter='Test twitter',
linkedin='Test linkedin',
facebook='Test facebook',
github_id='12345',
gravatar_id='test gravatar id',
googleplus='Test googleplus',
foursquare='Test foursquare',
personal_web='Test personal web',
token_github='test github token')
user = user.save()
self.id = user.id
def request_to_class(json_request):
user = User()
name = json_request.get('name', None)
information_datas = json_request.get('information', {})
events_datas = json_request.get('events', [])
user.name = name
if information_datas is not None:
for k, v in information_datas.items():
if k in user.model['information']:
user.model['information'][k] = v
if events_datas is not None:
for events_data in events_datas:
event = Event()
for k, v in events_data.items():
if k in event.model:
event.model[k] = v
user.events.append(event)
return user
def wrapper(*args, **kwargs):
user = is_user_logged()
if isinstance(user, UserEntity):
g.user = User.from_model(user)
return fn(*args, **kwargs)
elif request.content_type == 'application/json':
logging.debug("No authorisation supplied")
abort(401, "Unauthorised")
else:
return redirect(url_for('main.login'))
def setUp(self):
self.app = app.test_client()
user = User(
username = '******',
email = '*****@*****.**',
job = 'Test Job',
city = 'Test City',
name = 'Test Name',
github = 'Test github',
twitter = 'Test twitter',
linkedin = 'Test linkedin',
facebook = 'Test facebook',
googleplus = 'Test googleplus',
foursquare = 'Test foursquare',
personal_web = 'Test personal web'
)
user = user.save()
self.id = user.id
self.username = user.username
def reg_user(self):
"""
Register a new user use form.data.
"""
self.validate_email(self.email)
self.validate_username(self.username)
user = User(email=self.email.data,
username=self.username.data,
password=self.password.data,
nickname=self.nickname.data)
db.session.add(user)
db.session.commit()
return user
def create_admin(email, password):
alphai_company = services.company.insert(
Company(name='alphai', domain='alpha-i.co')
)
user = User(
email=email,
confirmed=True,
company_id=alphai_company.id,
password=password,
permissions=UserPermissions.ADMIN
)
user = services.user.insert(user)
return user
def wrapper(*args, **kwargs):
user = is_user_logged()
if isinstance(user, UserEntity):
g.user = User.from_model(user)
return fn(*args, **kwargs)
else:
if request.accept_mimetypes.best in [
'application/html', 'text/html'
]:
return redirect(url_for('main.login'))
else:
logging.debug("No authorisation supplied")
abort(401, "Unauthorised")
def find_or_create_user(first_name, last_name, email, password, role=None):
""" Find existing user or create new user """
user = User.query.filter(User.email == email).first()
if not user:
user = User(email=email,
first_name=first_name,
last_name=last_name,
password=app.user_manager.hash_password(password),
active=True,
confirmed_at=datetime.utcnow())
if role:
user.roles.append(role)
db.session.add(user)
return user
def testUserSettingSave(self):
with app.test_client() as c:
with c.session_transaction() as sess:
sess['user_id'] = self.id
post = dict(
username='******',
email='*****@*****.**',
job='Test Job 2',
city='Test City 2',
name='Test Name 2',
github='Test github 2',
twitter='Test twitter 2',
linkedin='Test linkedin 2',
facebook='Test facebook 2',
googleplus='Test googleplus 2',
foursquare='Test foursquare 2',
personal_web='Test personal web 2',
)
rv = c.post('/user/settings', data=post)
self.assertEquals(rv.status_code, 200)
self.assertTrue('Test username 2' in rv.data)
self.assertTrue('*****@*****.**' in rv.data)
self.assertTrue('Test Job 2' in rv.data)
self.assertTrue('Test City 2' in rv.data)
self.assertTrue('Test Name 2' in rv.data)
self.assertTrue('Test github 2' in rv.data)
self.assertTrue('Test twitter 2' in rv.data)
self.assertTrue('Test linkedin 2' in rv.data)
self.assertTrue('Test facebook 2' in rv.data)
self.assertTrue('Test googleplus 2' in rv.data)
self.assertTrue('Test foursquare 2' in rv.data)
self.assertTrue('Test personal web 2' in rv.data)
user = User.objects(id=self.id).first()
self.assertEquals(post['username'], user.username)
self.assertEquals(post['email'], user.email)
self.assertEquals(post['job'], user.job)
self.assertEquals(post['city'], user.city)
self.assertEquals(post['name'], user.name)
self.assertEquals(post['github'], user.github)
self.assertEquals(post['twitter'], user.twitter)
self.assertEquals(post['linkedin'], user.linkedin)
self.assertEquals(post['facebook'], user.facebook)
self.assertEquals(post['googleplus'], user.googleplus)
self.assertEquals(post['foursquare'], user.foursquare)
self.assertEquals(post['personal_web'], user.personal_web)
def register():
email = g.json.get('email')
password = g.json.get('password')
assert email and password, abort(
400, 'Please specify a user email and password')
company = services.company.get_for_email(email)
if not company:
logging.warning("No company could be found for %s", email)
abort(400, f"No company could be found for {email}")
if not is_valid_email_for_company(email, company):
logging.warning("Invalid email %s for company: %s", email,
company.domain)
abort(401, f"Invalid email {email} for company: {company.domain}")
user = services.user.get_by_email(email)
if user is not None:
abort(400, 'Cannot register an existing user!')
user = User(email=email,
confirmed=False,
company_id=company.id,
password=password)
user = services.user.insert(user)
confirmation_token = generate_confirmation_token(user.email)
logging.info("Confirmation token for %s: %s", user.email,
confirmation_token)
# Only admins can create users for now
#services.email.send_confirmation_email(user.email, confirmation_token)
response = ApiResponse(content_type=request.accept_mimetypes.best,
next=url_for('main.login'),
status_code=201,
context={
'email': user.email,
'id': user.id,
'confirmation_token': confirmation_token
})
return response()
def signup():
if current_user.is_authenticated:
return redirect(url_for('bp.home'))
form = SignupForm()
if form.validate_on_submit():
user = User(username=form.username.data,
password=form.password.data,
fullname=form.fullname.data,
email=form.email.data)
user.store_password(form.password.data)
user.create()
return redirect(url_for('bp.signin'))
return render_template('signup.html', form=form)
def find_or_create_user(user_id,
username,
first_name,
last_name,
email,
password,
reg_ip,
role=None):
""" Find existing user or create new user """
user = User.query.filter(User.email == email).first()
if not user:
user = User(username=username,
email=email,
first_name=first_name,
last_name=last_name,
password=app.user_manager.hash_password(password),
active=True,
confirmed_at=datetime.utcnow(),
reg_ip=reg_ip)
if role:
user.roles.append(role)
db.session.add(user)
#OpenZeka: add user usage limit information
i = datetime.now()
usage_date = "%s,%s,%s" % (i.day, i.month, i.year)
today = datetime.now()
next_month = add_months(today, 1)
item = Usage(
user_id=user_id,
# Adding 25000 limit for admin, user.
usages=usage_date + "," + str(next_month[0]) + ',' +
str(next_month[1]) + ',' + str(next_month[2]) + ",0,25000"
# usages=usage_date + "," + str(next_month[0]) + ',' + str(next_month[1]) + ',' + str(
# next_month[2]) + ",0,25000;" + usage_date + "," + str(next_month[-1]) + ',' + str(next_month[0]) + ',' + str(
# next_month[2]) + ",18500,25000;"
)
db.session.add(item)
return user
def testFoursquare(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.foursquare, 'Test foursquare')
def testGooglePlus(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.googleplus, 'Test googleplus')
def testFaceBook(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.facebook, 'Test facebook')
def testLinkedin(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.linkedin, 'Test linkedin')
def testTwitter(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.twitter, 'Test twitter')
def testPersonalWeb(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.personal_web, 'Test personal web')
def testName(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.name, 'Test Name')
def insert(user):
model = user.to_model()
model.hash_password(password=model.password)
model.save()
return User.from_model(model)
def confirm(user):
model = user._model
model.confirmed = True
model.save()
return User.from_model(model)
def testGithubToken(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.token_github, 'test github token')
def test_read_user_should_return_user_if_found(read_user_response, user):
response_user = User(**read_user_response.json())
assert response_user.id == user.id
def tearDown(self):
User.drop_collection()
def testGravatarID(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.gravatar_id, 'test gravatar id')
def testGithub(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.github, 'Test github')
def tearDown(self):
User.drop_collection()
def testGithubID(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.github_id, 12345)
def generate_user():
return User(email=faker.email(),
username=faker.word(),
nickname=faker.name(),
password='******')
def testJob(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.job, 'Test Job')
def testCity(self):
user = User.objects(id=self.id).first()
self.assertEquals(user.city, 'Test City')
def check_or_create(self, token, auth_type):
if auth_type == 'github':
github = Github()
user_info = github.get_user_info(token)
user = User.objects(github_id=user_info['id']).first()
if not user:
user = User()
email_github = github.get_email(token)
user.token_github = token
user.github = user_info['html_url']
user.email = email_github[0]
user.name = user_info['name']
user.username = user_info['login']
user.city = user_info['location']
user.gravatar_id = user_info['gravatar_id']
user.github_id =user_info['id']
user.save()
self.create_auth_session(user.id, token, auth_type)
return self.create_auth_session(user.id, token, auth_type)
else:
return False
