406 lines
12 KiB
Python
406 lines
12 KiB
Python
import enum
|
|
import hashlib
|
|
|
|
import arrow
|
|
import bcrypt
|
|
import stripe
|
|
from arrow import Arrow
|
|
from flask_login import UserMixin
|
|
from sqlalchemy_utils import ArrowType
|
|
|
|
from app import s3
|
|
from app.config import URL, MAX_NB_EMAIL_FREE_PLAN, EMAIL_DOMAIN
|
|
from app.extensions import db
|
|
from app.log import LOG
|
|
from app.oauth_models import ScopeE
|
|
from app.utils import convert_to_id, random_string
|
|
|
|
|
|
class ModelMixin(object):
|
|
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
|
|
created_at = db.Column(ArrowType, default=arrow.utcnow, nullable=False)
|
|
updated_at = db.Column(ArrowType, default=None, onupdate=arrow.utcnow)
|
|
|
|
_repr_hide = ["created_at", "updated_at"]
|
|
|
|
@classmethod
|
|
def query(cls):
|
|
return db.session.query(cls)
|
|
|
|
@classmethod
|
|
def get(cls, id):
|
|
return cls.query.get(id)
|
|
|
|
@classmethod
|
|
def get_by(cls, **kw):
|
|
return cls.query.filter_by(**kw).first()
|
|
|
|
@classmethod
|
|
def filter_by(cls, **kw):
|
|
return cls.query.filter_by(**kw)
|
|
|
|
@classmethod
|
|
def get_or_create(cls, **kw):
|
|
r = cls.get_by(**kw)
|
|
if not r:
|
|
r = cls(**kw)
|
|
db.session.add(r)
|
|
|
|
return r
|
|
|
|
@classmethod
|
|
def create(cls, **kw):
|
|
r = cls(**kw)
|
|
db.session.add(r)
|
|
return r
|
|
|
|
def save(self):
|
|
db.session.add(self)
|
|
|
|
def delete(self):
|
|
db.session.delete(self)
|
|
|
|
def __repr__(self):
|
|
values = ", ".join(
|
|
"%s=%r" % (n, getattr(self, n))
|
|
for n in self.__table__.c.keys()
|
|
if n not in self._repr_hide
|
|
)
|
|
return "%s(%s)" % (self.__class__.__name__, values)
|
|
|
|
|
|
class File(db.Model, ModelMixin):
|
|
path = db.Column(db.String(128), unique=True, nullable=False)
|
|
|
|
def get_url(self):
|
|
return s3.get_url(self.path)
|
|
|
|
|
|
class PlanEnum(enum.Enum):
|
|
free = 0
|
|
trial = 1
|
|
monthly = 2
|
|
yearly = 3
|
|
|
|
|
|
class User(db.Model, ModelMixin, UserMixin):
|
|
__tablename__ = "users"
|
|
email = db.Column(db.String(128), unique=True, nullable=False)
|
|
salt = db.Column(db.String(128), nullable=False)
|
|
password = db.Column(db.String(128), nullable=False)
|
|
name = db.Column(db.String(128), nullable=False)
|
|
is_admin = db.Column(db.Boolean, nullable=False, default=False)
|
|
|
|
activated = db.Column(db.Boolean, default=False, nullable=False)
|
|
|
|
plan = db.Column(
|
|
db.Enum(PlanEnum),
|
|
nullable=False,
|
|
default=PlanEnum.free,
|
|
server_default=PlanEnum.free.name,
|
|
)
|
|
|
|
# only relevant for trial period
|
|
plan_expiration = db.Column(ArrowType)
|
|
|
|
stripe_customer_id = db.Column(db.String(128), unique=True)
|
|
stripe_card_token = db.Column(db.String(128), unique=True)
|
|
stripe_subscription_id = db.Column(db.String(128), unique=True)
|
|
|
|
profile_picture_id = db.Column(db.ForeignKey(File.id), nullable=True)
|
|
is_developer = db.Column(db.Boolean, nullable=False, server_default="0")
|
|
|
|
# contain the list of promo codes user has used. Promo codes are separated by ","
|
|
promo_codes = db.Column(db.Text, nullable=True)
|
|
|
|
profile_picture = db.relationship(File)
|
|
|
|
def should_upgrade(self):
|
|
"""User is invited to upgrade if they are in free plan or their trial ends soon"""
|
|
if self.plan == PlanEnum.free:
|
|
return True
|
|
elif self.plan == PlanEnum.trial and self.plan_expiration < arrow.now().shift(
|
|
weeks=1
|
|
):
|
|
return True
|
|
return False
|
|
|
|
def is_premium(self):
|
|
return self.plan in (PlanEnum.monthly, PlanEnum.yearly)
|
|
|
|
def can_create_new_email(self):
|
|
if self.is_premium():
|
|
return True
|
|
# plan not expired yet
|
|
elif self.plan == PlanEnum.trial and self.plan_expiration > arrow.now():
|
|
return True
|
|
else: # free or trial expired
|
|
return GenEmail.filter_by(user_id=self.id).count() < MAX_NB_EMAIL_FREE_PLAN
|
|
|
|
def set_password(self, password):
|
|
salt = bcrypt.gensalt()
|
|
password_hash = bcrypt.hashpw(password.encode(), salt).decode()
|
|
self.salt = salt.decode()
|
|
self.password = password_hash
|
|
|
|
def check_password(self, password) -> bool:
|
|
password_hash = bcrypt.hashpw(password.encode(), self.salt.encode())
|
|
return self.password.encode() == password_hash
|
|
|
|
def profile_picture_url(self):
|
|
if self.profile_picture_id:
|
|
return self.profile_picture.get_url()
|
|
else: # use gravatar
|
|
hash_email = hashlib.md5(self.email.encode("utf-8")).hexdigest()
|
|
return f"https://www.gravatar.com/avatar/{hash_email}"
|
|
|
|
def plan_current_period_end(self) -> Arrow:
|
|
if not self.stripe_subscription_id:
|
|
LOG.error(
|
|
"plan_current_period_end should not be called with empty stripe_subscription_id"
|
|
)
|
|
return None
|
|
|
|
current_period_end_ts = stripe.Subscription.retrieve(
|
|
self.stripe_subscription_id
|
|
)["current_period_end"]
|
|
|
|
return arrow.get(current_period_end_ts)
|
|
|
|
def get_promo_codes(self) -> [str]:
|
|
if not self.promo_codes:
|
|
return []
|
|
return self.promo_codes.split(",")
|
|
|
|
def save_new_promo_code(self, promo_code):
|
|
current_promo_codes = self.get_promo_codes()
|
|
current_promo_codes.append(promo_code)
|
|
|
|
self.promo_codes = ",".join(current_promo_codes)
|
|
|
|
|
|
class ActivationCode(db.Model, ModelMixin):
|
|
"""For activate user account"""
|
|
|
|
user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False)
|
|
code = db.Column(db.String(128), unique=True, nullable=False)
|
|
|
|
user = db.relationship(User)
|
|
|
|
# the activation code is valid for 1h
|
|
expired = db.Column(ArrowType, default=arrow.now().shift(hours=1))
|
|
|
|
|
|
class ResetPasswordCode(db.Model, ModelMixin):
|
|
"""For resetting password"""
|
|
|
|
user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False)
|
|
code = db.Column(db.String(128), unique=True, nullable=False)
|
|
|
|
user = db.relationship(User)
|
|
|
|
# the activation code is valid for 1h
|
|
expired = db.Column(ArrowType, default=arrow.now().shift(hours=1), nullable=False)
|
|
|
|
|
|
class Partner(db.Model, ModelMixin):
|
|
email = db.Column(db.String(128))
|
|
name = db.Column(db.String(128))
|
|
website = db.Column(db.String(1024))
|
|
additional_information = db.Column(db.Text)
|
|
|
|
# If apply from a authenticated user, set user_id to the user who has applied for partnership
|
|
user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=True)
|
|
|
|
|
|
# <<< OAUTH models >>>
|
|
|
|
client_scope = db.Table(
|
|
"client_scope",
|
|
db.Column(
|
|
"client_id",
|
|
db.Integer,
|
|
db.ForeignKey("client.id", ondelete="cascade"),
|
|
primary_key=True,
|
|
nullable=False,
|
|
),
|
|
db.Column(
|
|
"scope_id",
|
|
db.Integer,
|
|
db.ForeignKey("scope.id", ondelete="cascade"),
|
|
primary_key=True,
|
|
nullable=False,
|
|
),
|
|
)
|
|
|
|
|
|
def generate_oauth_client_id(client_name) -> str:
|
|
oauth_client_id = convert_to_id(client_name) + "-" + random_string()
|
|
|
|
# check that the client does not exist yet
|
|
if not Client.get_by(oauth_client_id=oauth_client_id):
|
|
LOG.debug("generate oauth_client_id %s", oauth_client_id)
|
|
return oauth_client_id
|
|
|
|
# Rerun the function
|
|
LOG.warning(
|
|
"client_id %s already exists, generate a new client_id", oauth_client_id
|
|
)
|
|
return generate_oauth_client_id(client_name)
|
|
|
|
|
|
class Client(db.Model, ModelMixin):
|
|
oauth_client_id = db.Column(db.String(128), unique=True, nullable=False)
|
|
oauth_client_secret = db.Column(db.String(128), nullable=False)
|
|
|
|
name = db.Column(db.String(128), nullable=False)
|
|
home_url = db.Column(db.String(1024))
|
|
published = db.Column(db.Boolean, default=False, nullable=False)
|
|
|
|
# user who created this client
|
|
user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False)
|
|
icon_id = db.Column(db.ForeignKey(File.id), nullable=True)
|
|
|
|
scopes = db.relationship("Scope", secondary=client_scope, lazy="subquery")
|
|
icon = db.relationship(File)
|
|
|
|
def nb_user(self):
|
|
return ClientUser.filter_by(client_id=self.id).count()
|
|
|
|
@classmethod
|
|
def create_new(cls, name, user_id) -> "Client":
|
|
# generate a client-id
|
|
oauth_client_id = generate_oauth_client_id(name)
|
|
oauth_client_secret = random_string(40)
|
|
client = Client.create(
|
|
name=name,
|
|
oauth_client_id=oauth_client_id,
|
|
oauth_client_secret=oauth_client_secret,
|
|
user_id=user_id,
|
|
)
|
|
|
|
# By default, add email and name scope
|
|
client.scopes.append(Scope.get_by(name=ScopeE.NAME.value))
|
|
client.scopes.append(Scope.get_by(name=ScopeE.EMAIL.value))
|
|
|
|
return client
|
|
|
|
def get_icon_url(self):
|
|
if self.icon_id:
|
|
return self.icon.get_url()
|
|
else:
|
|
return URL + "/static/default-icon.svg"
|
|
|
|
|
|
class RedirectUri(db.Model, ModelMixin):
|
|
"""Valid redirect uris for a client"""
|
|
|
|
client_id = db.Column(db.ForeignKey(Client.id, ondelete="cascade"), nullable=False)
|
|
uri = db.Column(db.String(1024), nullable=False)
|
|
|
|
client = db.relationship(Client, backref="redirect_uris")
|
|
|
|
|
|
class AuthorizationCode(db.Model, ModelMixin):
|
|
code = db.Column(db.String(128), unique=True, nullable=False)
|
|
client_id = db.Column(db.ForeignKey(Client.id, ondelete="cascade"), nullable=False)
|
|
user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False)
|
|
|
|
scope = db.Column(db.String(128))
|
|
redirect_uri = db.Column(db.String(1024))
|
|
|
|
user = db.relationship(User, lazy=False)
|
|
client = db.relationship(Client, lazy=False)
|
|
|
|
|
|
class OauthToken(db.Model, ModelMixin):
|
|
access_token = db.Column(db.String(128), unique=True)
|
|
client_id = db.Column(db.ForeignKey(Client.id, ondelete="cascade"), nullable=False)
|
|
user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False)
|
|
|
|
scope = db.Column(db.String(128))
|
|
redirect_uri = db.Column(db.String(1024))
|
|
|
|
user = db.relationship(User)
|
|
client = db.relationship(Client)
|
|
|
|
|
|
class Scope(db.Model, ModelMixin):
|
|
name = db.Column(db.String(128), unique=True, nullable=False)
|
|
|
|
|
|
def generate_email() -> str:
|
|
"""generate an email address that does not exist before"""
|
|
random_email = random_string(40) + "@" + EMAIL_DOMAIN
|
|
|
|
# check that the client does not exist yet
|
|
if not GenEmail.get_by(email=random_email):
|
|
LOG.debug("generate email %s", random_email)
|
|
return random_email
|
|
|
|
# Rerun the function
|
|
LOG.warning("email %s already exists, generate a new email", random_email)
|
|
return generate_email()
|
|
|
|
|
|
class GenEmail(db.Model, ModelMixin):
|
|
"""Generated email"""
|
|
|
|
user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False)
|
|
email = db.Column(db.String(128), unique=True, nullable=False)
|
|
|
|
enabled = db.Column(db.Boolean(), default=True, nullable=False)
|
|
|
|
@classmethod
|
|
def create_new_gen_email(cls, user_id):
|
|
random_email = generate_email()
|
|
return GenEmail.create(user_id=user_id, email=random_email)
|
|
|
|
def __repr__(self):
|
|
return f"<GenEmail {self.id} {self.email}>"
|
|
|
|
|
|
class ClientUser(db.Model, ModelMixin):
|
|
__table_args__ = (
|
|
db.UniqueConstraint("user_id", "client_id", name="uq_client_user"),
|
|
)
|
|
|
|
user_id = db.Column(db.ForeignKey(User.id, ondelete="cascade"), nullable=False)
|
|
client_id = db.Column(db.ForeignKey(Client.id, ondelete="cascade"), nullable=False)
|
|
|
|
# Null means client has access to user original email
|
|
gen_email_id = db.Column(
|
|
db.ForeignKey(GenEmail.id, ondelete="cascade"), nullable=True
|
|
)
|
|
|
|
gen_email = db.relationship(GenEmail, backref="client_users")
|
|
|
|
user = db.relationship(User)
|
|
client = db.relationship(Client)
|
|
|
|
def get_email(self):
|
|
return self.gen_email.email if self.gen_email_id else self.user.email
|
|
|
|
def get_user_info(self) -> dict:
|
|
"""return user info according to client scope
|
|
Return dict with key being scope name
|
|
|
|
"""
|
|
res = {"id": self.id, "client": self.client.name, "email_verified": True}
|
|
|
|
for scope in self.client.scopes:
|
|
if scope.name == ScopeE.NAME.value:
|
|
res[ScopeE.NAME.value] = self.user.name
|
|
elif scope.name == ScopeE.EMAIL.value:
|
|
# Use generated email
|
|
if self.gen_email_id:
|
|
LOG.debug(
|
|
"Use gen email for user %s, client %s", self.user, self.client
|
|
)
|
|
res[ScopeE.EMAIL.value] = self.gen_email.email
|
|
# Use user original email
|
|
else:
|
|
res[ScopeE.EMAIL.value] = self.user.email
|
|
|
|
return res
|