def setUp(self):
super(BaseUserConfig, self).setUp()
self._user = User.create(
email_address=test_user["emailAddress"],
password=test_user["password"],
display_name=test_user["displayName"],
title=test_user["title"],
)
self._user.email_verification.has_verified = True
db.session.add(self._user)
sm = SocialMedia(service=test_user['socialMedias'][0]['service'],
username=test_user['socialMedias'][0]['username'],
user_id=self._user.id)
db.session.add(sm)
avatar = Avatar(image_url=test_user["avatar"]["link"],
user_id=self._user.id)
db.session.add(avatar)
self.user_password = test_user["password"]
self._other_user = User.create(
email_address=test_other_user["emailAddress"],
password=test_other_user["password"],
display_name=test_other_user["displayName"],
title=test_other_user["title"])
self.other_user_password = test_other_user["password"]
db.session.commit()
self._user_id = self._user.id
self._other_user_id = self._other_user.id
def make_envelope(to, type, email_args):
if current_app and current_app.config.get("TESTING"):
return None
from grant.user.models import User
user = User.get_by_email(to)
info = get_info_lookup[type](email_args)
if user and 'subscription' in info:
sub = info['subscription']
if user and not is_subscribed(user.settings.email_subscriptions, sub):
current_app.logger.debug(f'Ignoring send_email to {to} of type {type} because user is unsubscribed.')
return None
email = generate_email(type, email_args, user)
mail = Mail(
from_email=Email(SENDGRID_DEFAULT_FROM, SENDGRID_DEFAULT_FROMNAME),
to_email=Email(to),
subject=email['info']['subject'],
)
mail.add_content(Content('text/plain', email['text']))
mail.add_content(Content('text/html', email['html']))
mail.___type = type
mail.___to = to
return mail
def send_admin_email(type: str, email_args: dict):
from grant.user.models import User
admins = User.get_admins()
for a in admins:
send_email(a.email_address, type, {
'user': a,
**email_args
})
def send_admin_email(self, type: str):
from grant.user.models import User
admins = User.get_admins()
for a in admins:
send_email(a.email_address, type, {
'user': a,
'ccr': self,
'ccr_url': make_admin_url(f'/ccrs/{self.id}'),
})
def auth_user(email, password):
existing_user = User.get_by_email(email)
if not existing_user:
raise AuthException("No user exists with that email")
if not existing_user.check_password(password):
raise AuthException("Invalid password")
throw_on_banned(existing_user)
existing_user.login()
session['last_login_time'] = datetime.now()
return existing_user
def create_user(key: str):
pw = f"e2epassword{key}"
user = User.create(
email_address=f"{key}@testing.e2e",
password=pw,
display_name=f"{key} Endtoenderson",
title=f"title{key}",
)
user.email_verification.has_verified = True
db.session.add(user)
db.session.flush()
dump = admin_user_schema.dump(user)
dump['password'] = pw
return dump
def test_create_user(self, mock_send_email):
mock_send_email.return_value.ok = True
self.app.post("/api/v1/users/",
data=json.dumps(test_team[0]),
content_type='application/json')
# User
user_db = User.get_by_identifier(
account_address=test_team[0]["accountAddress"])
self.assertEqual(user_db.display_name, test_team[0]["displayName"])
self.assertEqual(user_db.title, test_team[0]["title"])
self.assertEqual(user_db.account_address,
test_team[0]["accountAddress"])
def setUp(self):
super(BaseUserConfig, self).setUp()
self.user = User.create(account_address=test_user["accountAddress"],
email_address=test_user["emailAddress"],
display_name=test_user["displayName"],
title=test_user["title"],
_send_email=False)
sm = SocialMedia(
social_media_link=test_user['socialMedias'][0]['link'],
user_id=self.user.id)
db.session.add(sm)
avatar = Avatar(image_url=test_user["avatar"]["link"],
user_id=self.user.id)
db.session.add(avatar)
db.session.commit()
def decorated(*args, **kwargs):
from grant.user.models import User
user_id = kwargs["user_id"]
if not user_id:
return jsonify(message="Decorator requires_same_user_auth requires path variable <user_id>"), 500
user = User.get_by_id(user_id=user_id)
if not user:
return jsonify(message="Could not find user with id {}".format(user_id)), 403
if user.id != g.current_user.id:
return jsonify(message="You are not authorized to modify this user"), 403
return f(*args, **kwargs)
def test_create_user(self, mock_send_email):
mock_send_email.return_value.ok = True
# Delete the user config user
db.session.delete(self.user)
db.session.commit()
response = self.app.post("/api/v1/users/",
data=json.dumps(test_user),
content_type='application/json')
self.assertStatus(response, 201)
# User
user_db = User.get_by_email(test_user["emailAddress"])
self.assertEqual(user_db.display_name, test_user["displayName"])
self.assertEqual(user_db.title, test_user["title"])
self.assertEqual(user_db.email_address, test_user["emailAddress"])
# should not be able to add social
self.assertFalse(user_db.social_medias)
def post_proposal_team_invite(proposal_id, address):
for u in g.current_proposal.team:
if address == u.email_address:
return {
"message": f"Cannot invite members already on the team"
}, 400
existing_invite = ProposalTeamInvite.query.filter_by(
proposal_id=proposal_id, address=address).first()
if existing_invite:
return {"message": f"You've already invited {address}"}, 400
invite = ProposalTeamInvite(proposal_id=proposal_id, address=address)
db.session.add(invite)
db.session.commit()
# Send email
email = address
user = User.get_by_email(email_address=address)
if user:
email = user.email_address
if is_email(email):
send_email(
email, 'team_invite', {
'user':
user,
'inviter':
g.current_user,
'proposal':
g.current_proposal,
'invite_url':
make_url(
f'/profile/{user.id}?tab=invites' if user else '/auth')
})
return proposal_team_invite_schema.dump(invite), 201
def make_proposal(crowd_fund_contract_address, content, title, milestones, category, team):
existing_proposal = Proposal.query.filter_by(proposal_address=crowd_fund_contract_address).first()
if existing_proposal:
return {"message": "Oops! Something went wrong."}, 409
proposal = Proposal.create(
stage="FUNDING_REQUIRED",
proposal_address=crowd_fund_contract_address,
content=content,
title=title,
category=category
)
db.session.add(proposal)
if not len(team) > 0:
return {"message": "Team must be at least 1"}, 400
for team_member in team:
account_address = team_member.get("accountAddress")
display_name = team_member.get("displayName")
email_address = team_member.get("emailAddress")
title = team_member.get("title")
user = User.query.filter(
(User.account_address == account_address) | (User.email_address == email_address)).first()
if not user:
user = User(
account_address=account_address,
email_address=email_address,
display_name=display_name,
title=title
)
db.session.add(user)
db.session.flush()
avatar_data = team_member.get("avatar")
if avatar_data:
avatar = Avatar(image_url=avatar_data.get('link'), user_id=user.id)
db.session.add(avatar)
social_medias = team_member.get("socialMedias")
if social_medias:
for social_media in social_medias:
sm = SocialMedia(social_media_link=social_media.get("link"), user_id=user.id)
db.session.add(sm)
proposal.team.append(user)
for each_milestone in milestones:
m = Milestone(
title=each_milestone["title"],
content=each_milestone["description"],
date_estimated=datetime.strptime(each_milestone["date"], '%B %Y'),
payout_percent=str(each_milestone["payoutPercent"]),
immediate_payout=each_milestone["immediatePayout"],
proposal_id=proposal.id
)
db.session.add(m)
try:
db.session.commit()
except IntegrityError as e:
print(e)
return {"message": "Oops! Something went wrong."}, 409
results = proposal_schema.dump(proposal)
return results, 201
