class TeamMember(Model):
id = db.Column(db.Integer(), primary_key=True)
team_id = db.Column(db.ForeignKey("team.id"), index=True, nullable=False)
user_id = db.Column(db.ForeignKey("user.id"), index=True, nullable=True)
invite_email = db.Column(db.String(255))
role = db.Column(db.String(), default='team_member')
inviter_id = db.Column(db.ForeignKey("user.id"))
invite_secret = db.Column(db.String(255), default=url_safe_token)
activated = db.Column(db.Boolean(), default=False)
team = db.relationship("Team", backref='members', lazy="joined")
user = db.relationship("User",
foreign_keys=[user_id],
backref='memberships')
inviter = db.relationship("User", foreign_keys=[inviter_id])
GDPR_EXPORT_COLUMNS = {
"invite_email": "Email the invite was sent to",
"activated": "Was the invite activated?",
"created": "When the invite was created",
"team_id": "What team was the invite for",
"inviter_id": "Who sent the invite",
"role": "Role on team"
}
@classmethod
def invite(cls, team, email, role, inviter):
invitee = User.lookup(email)
if (not invitee):
member = cls(team=team,
invite_email=email,
role=role,
inviter=inviter)
else:
member = cls(team=team, user=invitee, role=role, inviter=inviter)
db.session.add(member)
db.session.commit()
InviteEmail(member).send()
@property
def email(self):
if self.user_id:
return self.user.email
return self.invite_email
def activate(self, user_id):
if not self.activated:
self.user_id = user_id
self.activated = True
db.session.add(self)
db.session.commit()
self.team.billing_plan.record_change_in_usage()
else:
raise Exception('Already activated')
class Team(Model):
"""
A team is a collection of users sharing the same resources.
All users get a team. Some teams have more than one member.
Most resources in the application should belong to a team.
Usage:
team.members -> [<TeamMember>, ...]
"""
id = db.Column(db.Integer(), primary_key=True)
creator_id = db.Column(db.ForeignKey("user.id"),
index=True,
nullable=False)
name = db.Column(db.String(255))
# Plan may need to become DB backed when billing is introduced.
plan = db.Column(db.String(), default='default')
creator = db.relationship("User")
GDPR_EXPORT_COLUMNS = {
"name": "Name of the time",
"plan": "What plan was",
"created": "When the team was created"
}
def has_member(self, user):
return user in [member.user for member in self.active_members]
@property
def active_members(self):
return [
membership for membership in self.members if membership.activated
]
@property
def active_teams(self):
return [
membership.team for membership in self.members
if membership.activated
]
@classmethod
@transaction
def create(cls, name, creator):
new_team = cls(name=name, creator=creator)
new_team_member = ModelProxy.teams.TeamMember(team=new_team,
user=creator,
role='administrator',
activated=True)
db.session.add(new_team)
db.session.add(new_team_member)
db.session.commit()
return new_team
class TeamMember(Model):
id = db.Column(db.Integer(), primary_key=True)
team_id = db.Column(db.ForeignKey("team.id"), index=True, nullable=False)
user_id = db.Column(db.ForeignKey("user.id"), index=True, nullable=True)
invite_email = db.Column(db.String(255))
role = db.Column(db.String(), default='team_member')
inviter_id = db.Column(db.ForeignKey("user.id"))
invite_secret = db.Column(db.String(255), default=url_safe_token)
activated = db.Column(db.Boolean(), default=False)
team = db.relationship("Team", backref='members', lazy="joined")
user = db.relationship("User",
foreign_keys=[user_id],
backref='memberships')
inviter = db.relationship("User", foreign_keys=[inviter_id])
GDPR_EXPORT_COLUMNS = {
"invite_email": "Email the invite was sent to",
"activated": "Was the invite activated?",
"created": "When the invite was created",
"team_id": "What team was the invite for",
"role": "Role on team"
}
@classmethod
def invite(cls, team, email, role, inviter):
invitee = User.lookup(email)
if (not invitee):
member = cls(team=team,
invite_email=email,
role=role,
inviter=inviter)
else:
member = cls(team=team, user=invitee, role=role, inviter=inviter)
db.session.add(member)
db.session.commit()
InviteEmail(member).send()
class TeamFile(Model):
id = db.Column(db.Integer(), primary_key=True)
team_id = db.Column(db.ForeignKey("team.id"), index=True,
nullable=False)
user_id = db.Column(db.ForeignKey("user.id"), index=True,
nullable=True)
file_name = db.Column(db.String())
description = db.Column(db.String())
file_object_name = db.Column(db.String())
activated = db.Column(db.Boolean(), default=False)
team = db.relationship("Team", backref='files', lazy="joined")
user = db.relationship("User", backref='team_files')
GDPR_EXPORT_COLUMNS = {
"created": "When the invite was created",
"team_id": "What team was the invite for",
"creator_id": "Who created the file",
"file_name": "The name of the file",
"description": "The description of the file",
}
class OAuth(Model, OAuthConsumerMixin):
__table_args__ = (db.UniqueConstraint("provider", "provider_user_id"), )
provider_user_id = db.Column(db.String(256), nullable=False)
provider_user_login = db.Column(db.String(256), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False)
user = db.relationship(
User,
# This `backref` thing sets up an `oauth` property on the User model,
# which is a dictionary of OAuth models associated with that user,
# where the dictionary key is the OAuth provider name.
backref=db.backref(
"oauth",
collection_class=attribute_mapped_collection("provider"),
cascade="all, delete-orphan",
),
)
GDPR_EXPORT_COLUMNS = {
"provider_user_login": "******",
"provider_user_id": "Provider User ID ",
"provider": "The provider",
"created_at": "When it was created"
}
class Team(Model):
"""
A team is a collection of users sharing the same resources.
All users get a team. Some teams have more than one member.
Most resources in the application should belong to a team.
Usage:
team.members -> [<TeamMember>, ...]
"""
id = db.Column(db.Integer(), primary_key=True)
creator_id = db.Column(db.ForeignKey("user.id"), index=True,
nullable=False)
name = db.Column(db.String(255))
# Plan may need to become DB backed when billing is introduced.
plan = db.Column(db.String(), default='free')
plan_owner_id = db.Column(db.ForeignKey("user.id"))
subscription_id = db.Column(db.String())
billing_customer_id = db.Column(db.String())
creator = db.relationship("User", foreign_keys=[creator_id])
plan_owner = db.relationship("User", foreign_keys=[plan_owner_id])
GDPR_EXPORT_COLUMNS = {
"id": "ID of the team",
"hashid": "ID of User",
"name": "Name of the team",
"plan": "What plan the team was on",
"created": "When the team was created"
}
def has_member(self, user):
return user in [member.user for member in self.active_members]
@property
def is_paid_plan(self):
return not self.billing_plan.is_free
@property
def billing_plan(self):
# TODO: Might benefit from a validation to ensure `plan` is a recognized type in billing_plans
billing_plan = plans_by_name.get(self.plan) or FreePlan
return billing_plan(self)
@property
def active_members(self):
return [membership for membership in self.members if membership.activated]
@property
def active_teams(self):
return [membership.team for membership in self.members if membership.activated]
@classmethod
@transaction
def create(cls, name, creator):
new_team = cls(name=name, creator=creator)
new_team_member = ModelProxy.teams.TeamMember(team=new_team, user=creator, role='administrator', activated=True)
db.session.add(new_team)
db.session.add(new_team_member)
db.session.commit()
return new_team