class Code(ResourceMixin, db.Model): """ 코드 모델 정의 클래스 """ __bind_key__ = 'gisdb' __tablename__ = 'codes' code = db.Column(db.String(20), primary_key=True) group_code = db.Column(db.String(20), db.ForeignKey('code_groups.code'), primary_key=True, index=True) is_use = db.Column(db.Boolean(), nullable=False, server_default='1') is_display = db.Column(db.Boolean(), nullable=False, server_default='1') display_order = db.Column(db.Integer, nullable=False, server_default='0') name = db.Column(db.String(30), nullable=False) definition = db.Column(db.String(300)) created_id = db.Column(db.Integer, nullable=False) updated_id = db.Column(db.Integer, nullable=False) def __init__(self, **kwargs): # Call Flask-SQLAlchemy's constructor. super(Code, self).__init__(**kwargs) @classmethod def find_by_group_code(cls, group_code): # 그룹코드로 가용한 코드 목록을 조회한다. codes = cls.query.join(CodeGroup). \ filter(cls.group_code == group_code). \ filter(CodeGroup.is_use == True). \ filter(cls.is_use == True). \ filter(cls.is_display == True). \ order_by(cls.display_order).all() return codes
class CodeGroup(ResourceMixin, db.Model): """ 코드 그룹 모델 정의 클래스 """ __bind_key__ = 'gisdb' __tablename__ = 'code_groups' code = db.Column(db.String(20), primary_key=True) is_use = db.Column(db.Boolean(), nullable=False) name = db.Column(db.String(30), nullable=False) definition = db.Column(db.String(300)) created_id = db.Column(db.Integer, nullable=False) updated_id = db.Column(db.Integer, nullable=False) def __init__(self, **kwargs): # Call Flask-SQLAlchemy's constructor. super(CodeGroup, self).__init__(**kwargs)
class Coupon(ResourceMixin, db.Model): DURATION = OrderedDict([ ('forever', 'Forever'), ('once', 'Once'), ('repeating', 'Repeating') ]) __tablename__ = 'coupons' id = db.Column(db.Integer, primary_key=True) # Coupon details. code = db.Column(db.String(128), index=True, unique=True) duration = db.Column(db.Enum(*DURATION, name='duration_types'), index=True, nullable=False, server_default='forever') amount_off = db.Column(db.Integer()) percent_off = db.Column(db.Integer()) currency = db.Column(db.String(8)) duration_in_months = db.Column(db.Integer()) max_redemptions = db.Column(db.Integer(), index=True) redeem_by = db.Column(AwareDateTime(), index=True) times_redeemed = db.Column(db.Integer(), index=True, nullable=False, default=0) valid = db.Column(db.Boolean(), nullable=False, server_default='1') def __init__(self, **kwargs): if self.code: self.code = self.code.upper() else: self.code = Coupon.random_coupon_code() # Call Flask-SQLAlchemy's constructor. super(Coupon, self).__init__(**kwargs) @hybrid_property def redeemable(self): """ Return coupons that are still redeemable. Coupons will become invalid once they run out on save. We want to explicitly do a date check to avoid having to hit Stripe's API to get back potentially valid codes. :return: SQLAlchemy query object """ is_redeemable = or_(self.redeem_by.is_(None), self.redeem_by >= datetime.datetime.now(pytz.utc)) return and_(self.valid, is_redeemable) @classmethod def search(cls, query): """ Search a resource by 1 or more fields. :param query: Search query :type query: str :return: SQLAlchemy filter """ if not query: return '' search_query = '%{0}%'.format(query) return or_(Coupon.code.ilike(search_query)) @classmethod def random_coupon_code(cls): """ Create a human readable random coupon code. :return: str """ charset = string.digits + string.ascii_uppercase charset = charset.replace('B', '').replace('I', '') charset = charset.replace('O', '').replace('S', '') charset = charset.replace('0', '').replace('1', '') random_chars = ''.join(choice(charset) for _ in range(14)) coupon_code = '{0}-{1}-{2}'.format(random_chars[0:4], random_chars[5:9], random_chars[10:14]) return coupon_code @classmethod def expire_old_coupons(cls, compare_datetime=None): """ Invalidate coupons that are past their redeem date. :param compare_datetime: Time to compare at :type compare_datetime: date :return: The result of updating the records """ if compare_datetime is None: compare_datetime = datetime.datetime.now(pytz.utc) Coupon.query.filter(Coupon.redeem_by <= compare_datetime) \ .update({Coupon.valid: not Coupon.valid}) return db.session.commit() @classmethod def create(cls, params): """ Return whether or not the coupon was created successfully. :return: bool """ payment_params = params payment_params['code'] = payment_params['code'].upper() if payment_params.get('amount_off'): payment_params['amount_off'] = \ dollars_to_cents(payment_params['amount_off']) PaymentCoupon.create(**payment_params) if 'id' in payment_params: payment_params['code'] = payment_params['id'] del payment_params['id'] if 'redeem_by' in payment_params: if payment_params.get('redeem_by') is not None: params['redeem_by'] = payment_params.get('redeem_by').replace( tzinfo=pytz.UTC) coupon = Coupon(**payment_params) db.session.add(coupon) db.session.commit() return True @classmethod def bulk_delete(cls, ids): """ Override the general bulk_delete method because we need to delete them one at a time while also deleting them on Stripe. :param ids: List of ids to be deleted :type ids: list :return: int """ delete_count = 0 for id in ids: coupon = Coupon.query.get(id) if coupon is None: continue # Delete on Stripe. stripe_response = PaymentCoupon.delete(coupon.code) # If successful, delete it locally. if stripe_response.get('deleted'): coupon.delete() delete_count += 1 return delete_count @classmethod def find_by_code(cls, code): """ Find a coupon by its code. :param code: Coupon code to find :type code: str :return: Coupon instance """ formatted_code = code.upper() coupon = Coupon.query.filter(Coupon.redeemable, Coupon.code == formatted_code).first() return coupon def redeem(self): """ Update the redeem stats for this coupon. :return: Result of saving the record """ self.times_redeemed += 1 if self.max_redemptions: if self.times_redeemed >= self.max_redemptions: self.valid = False return db.session.commit() def apply_discount_to(self, amount): """ Apply the discount to an amount. :param amount: Amount in cents :type amount: int :return: int """ if self.amount_off: amount -= self.amount_off elif self.percent_off: amount *= (1 - (self.percent_off * 0.01)) return int(amount) def to_json(self): """ Return JSON fields to represent a coupon. :return: dict """ params = { 'duration': self.duration, 'duration_in_months': self.duration_in_months, } if self.amount_off: params['amount_off'] = cents_to_dollars(self.amount_off) if self.percent_off: params['percent_off'] = self.percent_off, return params
class User(UserMixin, ResourceMixin, db.Model): ROLE = OrderedDict([('member', 'Member'), ('admin', 'Admin')]) __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) # Relationships. credit_card = db.relationship(CreditCard, uselist=False, backref='users', passive_deletes=True) subscription = db.relationship(Subscription, uselist=False, backref='users', passive_deletes=True) invoices = db.relationship(Invoice, backref='users', passive_deletes=True) bets = db.relationship(Bet, backref='bets', passive_deletes=True) posts = db.relationship(Post, backref='users', passive_deletes=True) # Authentication. role = db.Column(db.Enum(*ROLE, name='role_types', native_enum=False), index=True, nullable=False, server_default='member') active = db.Column('is_active', db.Boolean(), nullable=False, server_default='1') username = db.Column(db.String(24), unique=True, index=True) email = db.Column(db.String(255), unique=True, index=True, nullable=False, server_default='') password = db.Column(db.String(128), nullable=False, server_default='') # Billing. name = db.Column(db.String(128), index=True) payment_id = db.Column(db.String(128), index=True) cancelled_subscription_on = db.Column(AwareDateTime()) previous_plan = db.Column(db.String(128)) # Bet. coins = db.Column(db.BigInteger()) last_bet_on = db.Column(AwareDateTime()) # Activity tracking. sign_in_count = db.Column(db.Integer, nullable=False, default=0) current_sign_in_on = db.Column(AwareDateTime()) current_sign_in_ip = db.Column(db.String(45)) last_sign_in_on = db.Column(AwareDateTime()) last_sign_in_ip = db.Column(db.String(45)) # Additional settings. locale = db.Column(db.String(5), nullable=False, server_default='en') def __init__(self, **kwargs): # Call Flask-SQLAlchemy's constructor. super(User, self).__init__(**kwargs) self.password = User.encrypt_password(kwargs.get('password', '')) self.coins = 100 @classmethod def find_by_identity(cls, identity): """ Find a user by their e-mail or username. :param identity: Email or username :type identity: str :return: User instance """ return User.query.filter((User.email == identity) | (User.username == identity)).first() @classmethod def encrypt_password(cls, plaintext_password): """ Hash a plaintext string using PBKDF2. This is good enough according to the NIST (National Institute of Standards and Technology). In other words while bcrypt might be superior in practice, if you use PBKDF2 properly (which we are), then your passwords are safe. :param plaintext_password: Password in plain text :type plaintext_password: str :return: str """ if plaintext_password: return generate_password_hash(plaintext_password) return None @classmethod def deserialize_token(cls, token): """ Obtain a user from de-serializing a signed token. :param token: Signed token. :type token: str :return: User instance or None """ private_key = TimedJSONWebSignatureSerializer( current_app.config['SECRET_KEY']) try: decoded_payload = private_key.loads(token) return User.find_by_identity(decoded_payload.get('user_email')) except Exception: return None @classmethod def initialize_password_reset(cls, identity): """ Generate a token to reset the password for a specific user. :param identity: User e-mail address or username :type identity: str :return: User instance """ u = User.find_by_identity(identity) reset_token = u.serialize_token() # This prevents circular imports. from hms.blueprints.user.tasks import (deliver_password_reset_email) deliver_password_reset_email.delay(u.id, reset_token) return u @classmethod def search(cls, query): """ Search a resource by 1 or more fields. :param query: Search query :type query: str :return: SQLAlchemy filter """ if not query: return '' search_query = '%{0}%'.format(query) search_chain = (User.email.ilike(search_query), User.username.ilike(search_query)) return or_(*search_chain) @classmethod def is_last_admin(cls, user, new_role, new_active): """ Determine whether or not this user is the last admin account. :param user: User being tested :type user: User :param new_role: New role being set :type new_role: str :param new_active: New active status being set :type new_active: bool :return: bool """ is_changing_roles = user.role == 'admin' and new_role != 'admin' is_changing_active = user.active is True and new_active is None if is_changing_roles or is_changing_active: admin_count = User.query.filter(User.role == 'admin').count() active_count = User.query.filter(User.is_active is True).count() if admin_count == 1 or active_count == 1: return True return False @classmethod def bulk_delete(cls, ids): """ Override the general bulk_delete method because we need to delete them one at a time while also deleting them on Stripe. :param ids: List of ids to be deleted :type ids: list :return: int """ delete_count = 0 for id in ids: user = User.query.get(id) if user is None: continue if user.payment_id is None: user.delete() else: subscription = Subscription() cancelled = subscription.cancel(user=user) # If successful, delete it locally. if cancelled: user.delete() delete_count += 1 return delete_count def is_active(self): """ Return whether or not the user account is active, this satisfies Flask-Login by overwriting the default value. :return: bool """ return self.active def get_auth_token(self): """ Return the user's auth token. Use their password as part of the token because if the user changes their password we will want to invalidate all of their logins across devices. It is completely fine to use md5 here as nothing leaks. This satisfies Flask-Login by providing a means to create a token. :return: str """ private_key = current_app.config['SECRET_KEY'] serializer = URLSafeTimedSerializer(private_key) data = [str(self.id), md5(self.password.encode('utf-8')).hexdigest()] return serializer.dumps(data) def authenticated(self, with_password=True, password=''): """ Ensure a user is authenticated, and optionally check their password. :param with_password: Optionally check their password :type with_password: bool :param password: Optionally verify this as their password :type password: str :return: bool """ if with_password: return check_password_hash(self.password, password) return True def serialize_token(self, expiration=3600): """ Sign and create a token that can be used for things such as resetting a password or other tasks that involve a one off token. :param expiration: Seconds until it expires, defaults to 1 hour :type expiration: int :return: JSON """ private_key = current_app.config['SECRET_KEY'] serializer = TimedJSONWebSignatureSerializer(private_key, expiration) return serializer.dumps({'user_email': self.email}).decode('utf-8') def update_activity_tracking(self, ip_address): """ Update various fields on the user that's related to meta data on their account, such as the sign in count and ip address, etc.. :param ip_address: IP address :type ip_address: str :return: SQLAlchemy commit results """ self.sign_in_count += 1 self.last_sign_in_on = self.current_sign_in_on self.last_sign_in_ip = self.current_sign_in_ip self.current_sign_in_on = datetime.datetime.now(pytz.utc) self.current_sign_in_ip = ip_address return self.save() def add_coins(self, plan): """ Add an amount of coins to an existing user. :param plan: Subscription plan :type plan: str :return: SQLAlchemy commit results """ self.coins += plan['metadata']['coins'] return self.save()
class User(UserMixin,db.Model): __tablename__ = 'users' # Unique identifier id = db.Column(db.Integer, primary_key=True, unique=True) # Patient data firstName = db.Column(db.String(32), nullable = False) lastName = db.Column(db.String(32), nullable = False) otherName = db.Column(db.String(32), nullable = True, server_default='') date_or_birth = db.Column(db.DateTime(), nullable = True) state_of_origin = db.Column(db.String(64), nullable=True) place_of_birth = db.Column(db.String(64), nullable=True) address = db.Column(db.String(120), nullable = True) gender = db.Column(db.String(10), nullable = True) # Patient login credentials username = db.Column(db.String(64), nullable = True, unique = True) email = db.Column(db.String(120), nullable=False, unique = True) password_hash = db.Column(db.String(128)) # Account status active = db.Column(db.Integer, server_default = '1', nullable = False) confirmed = db.Column(db.Boolean(), default = False) def __init__(self, **kwargs): super().__init__(**kwargs) @property def password(self): raise AttributeError("password is not a readable attribute") @password.setter def password(self, password): self.password_hash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password_hash, password) def is_active(self): """ Help to check whether the account is still active or not.""" return self.active @classmethod def find_by_identity(cls, identity): return User.query.filter((User.email == identity ) | (User.username == identity)).first() def serialize_confirmation_token(self, expiration=500): s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration) return s.dumps({'confirm' : self.id}).decode('utf-8') def disserialize_confirmation_token(self, token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) except: return False if data.get('confirm') != self.id: return False self.confirmed = True db.session.commit() return User.query.get(data.get('confirm')) def generate_reset_password(self, expiration=500): s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration) return s.dumps({'confirm' : self.id}).decode('utf-8') @staticmethod def reset_pasword(token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token.encode('utf-8')) except: return False return User.query.get(data.get('confirm')) def generate_email_token(self, email, expiration=500): s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration) return s.dumps({'confirm' : self.id, 'new_email' : email}) def confirm_email_token(self, token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token.encode('utf-8')) except: return False user = User.query.get(data.get('confirm')) new_email = User.query.get(data.get('new_email')) if data.get('confirm') != self.id: return False if User.query.filter_by(email = new_email ).first(): return False if user is None: return False user.email = new_email db.session.add(self) return True
class CreditCard(ResourceMixin, db.Model): IS_EXPIRING_THRESHOLD_MONTHS = 2 __tablename__ = 'credit_cards' id = db.Column(db.Integer, primary_key=True) # Relationships. user_id = db.Column(db.Integer, db.ForeignKey('users.id', onupdate='CASCADE', ondelete='CASCADE'), index=True, nullable=False) # Card details. brand = db.Column(db.String(32)) last4 = db.Column(db.Integer) exp_date = db.Column(db.Date, index=True) is_expiring = db.Column(db.Boolean(), nullable=False, server_default='0') def __init__(self, **kwargs): # Call Flask-SQLAlchemy's constructor. super(CreditCard, self).__init__(**kwargs) @classmethod def is_expiring_soon(cls, compare_date=None, exp_date=None): """ Determine whether or not this credit card is expiring soon. :param compare_date: Date to compare at :type compare_date: date :param exp_date: Expiration date :type exp_date: date :return: bool """ return exp_date <= timedelta_months( CreditCard.IS_EXPIRING_THRESHOLD_MONTHS, compare_date=compare_date) @classmethod def mark_old_credit_cards(cls, compare_date=None): """ Mark credit cards that are going to expire soon or have expired. :param compare_date: Date to compare at :type compare_date: date :return: Result of updating the records """ today_with_delta = timedelta_months( CreditCard.IS_EXPIRING_THRESHOLD_MONTHS, compare_date) CreditCard.query.filter(CreditCard.exp_date <= today_with_delta) \ .update({CreditCard.is_expiring: True}) return db.session.commit() @classmethod def extract_card_params(cls, customer): """ Extract the credit card info from a payment customer object. :param customer: Payment customer :type customer: Payment customer :return: dict """ card_data = customer.sources.data[0] exp_date = datetime.date(card_data.exp_year, card_data.exp_month, 1) card = { 'brand': card_data.brand, 'last4': card_data.last4, 'exp_date': exp_date, 'is_expiring': CreditCard.is_expiring_soon(exp_date=exp_date) } return card