class MonsterCard(Card):
__tablename__ = 'monsters'
attack = db.Column(db.String(4))
defense = db.Column(db.String(4))
stars = db.Column(db.Integer)
attribute = db.Column(db.Enum('dark', 'divine', 'earth', 'fire', 'light', 'water', 'wind', name='attribute'))
species = db.Column(db.Enum('aqua', 'beast', 'beast-warrior', 'creator god', 'cyberse', 'dinosaur', 'divine-beast', 'dragon', 'fairy', 'fiend', 'fish', 'insect', 'machine', 'plant', 'psychic', 'pyro', 'reptile', 'rock', 'sea serpent', 'spellcaster', 'thunder', 'warrior', 'winged beast', 'wyrm', 'zombie'))
types = db.relationship('MonsterType', secondary=monsterstypes, backref=db.backref('monsters', lazy='dynamic'))
__mapper_args__ = {'polymorphic_identity': 'monster'}
def __init__ (self, codepass, name, text, image, thumbnail, illegal, has_name_condition, attack, defense, stars, attribute, species):
self.codepass = codepass
self.name = name
self.text = text
self.image = image
self.thumbnail = thumbnail
self.illegal = illegal
self.has_name_condition = has_name_condition
self.attack = attack
self.defense = defense
self.stars = stars
self.attribute = attribute
self.species = species
class Proposal(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(250))
status = db.Column(db.Enum(Status), default=Status.DRAFT)
level = db.Column(db.Enum(Level), default=Level.BASIC)
description = db.Column(db.String(512))
speaker_id = db.Column(db.Integer,
db.ForeignKey('person.id'),
nullable=False)
class Whistle(db.Model):
__tablename__ = 'whistles'
id = db.Column(db.String(64), primary_key=True)
hash = db.Column(db.String(33), nullable=False)
facility_type = db.Column(db.Enum(FacilityType), nullable=False)
district_state = db.Column(db.String, nullable=False)
district = db.Column(db.Integer, nullable=False)
reporter_type = db.Column(db.Enum(ReporterType), nullable=False)
created_date = db.Column(db.DateTime, nullable=False)
start_date = db.Column(db.DateTime, nullable=True)
end_date = db.Column(db.DateTime, nullable=True)
def __init__(self,
hash=None,
report_date=None,
facility_type=FacilityType.hospital,
district_state=None,
district=None,
start_date=None,
end_date=None,
reporter_type=ReporterType.lpn,
**kwargs):
self.id = str(uuid.uuid4())
if start_date is None:
self.start_date = datetime.now()
else:
# self.start_date = parser.parse(start_date)
self.start_date = datetime.fromtimestamp(start_date)
if end_date is None:
self.end_date = datetime.now()
else:
# self.end_date = parser.parse(end_date)
self.end_date = datetime.fromtimestamp(end_date)
self.hash = hash
self.facility_type = facility_type
self.district_state = district_state
self.district = district
self.reporter_type = reporter_type
self.created_date = datetime.utcnow()
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
def as_simple_dict(self):
data = self.as_dict()
data.pop('id', None)
data.pop('hash', None)
data.pop('created_date', None)
return data
class Person(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(512))
last_name = db.Column(db.String(512))
email = db.Column(db.String(512))
country = db.Column(db.String(512))
role = db.Column(db.Enum(Role))
class CIRelation(db.Model):
__tablename__ = "ci_relations"
cr_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
first_ci_id = db.Column(db.Integer,
db.ForeignKey("cis.ci_id"),
primary_key=True)
second_ci_id = db.Column(db.Integer,
db.ForeignKey("cis.ci_id"),
primary_key=True)
first_ci = db.relationship("CI",
primaryjoin="CI.ci_id==CIRelation.first_ci_id")
second_ci = db.relationship(
"CI", primaryjoin="CI.ci_id==CIRelation.second_ci_id")
relation_type = db.Column(db.String(8),
db.Enum("connect",
"deploy",
"install",
"contain",
name="relation_type"),
nullable=False)
more = db.Column(db.Integer, db.ForeignKey("cis.ci_id"))
__table_args__ = (db.UniqueConstraint("first_ci_id",
"second_ci_id",
name="first_second_uniq"), )
class User(db.Model):
id = db.Column(db.String(80), primary_key=True, nullable=False)
# 1(Organisation)-to-many(User)
org_id = db.Column(db.String(80),
db.ForeignKey('organisation.id'),
nullable=False)
username = db.Column(db.String(120), nullable=False)
email = db.Column(db.String(120), nullable=False)
password = db.Column(db.String(256), nullable=False)
name = db.Column(db.String(120), nullable=False)
user_type = db.Column(db.Enum(UserType), nullable=False)
created_at = db.Column(db.DateTime(), nullable=False)
# 1(User)-to-Many(ProjectManager)
project_managers = db.relationship('ProjectManager', backref='user')
labels = db.relationship('Label', backref='user',
lazy=True) # 1(User)-to-Many(Label)
def __repr__(self):
return f"<User {self.id} | {self.username} ({self.name}) ({self.email}) | Organisation : {self.org_id}>"
def to_response(self):
return {
"orgId": self.org_id,
"username": self.username,
"email": self.email,
"userType": self.user_type.name,
"name": self.name,
"id": self.id,
"created_at": self.created_at
}
class Apply(db.Model):
__table_args__ = {'extend_existing': True}
apply_id = db.Column(db.Integer,
autoincrement=True,
primary_key=True,
nullable=False)
activity_name = db.Column(db.String(255), nullable=False)
applicant_id = db.Column(db.String(255), nullable=False)
applicant_name = db.Column(db.String(255), nullable=False)
applicant_phone = db.Column(db.String(255), nullable=False)
apply_time = db.Column(db.DateTime, nullable=False)
use_date = db.Column(db.String(255), nullable=False)
begin_time = db.Column(db.Integer, nullable=False)
end_time = db.Column(db.Integer, nullable=False)
people_count = db.Column(db.Integer, nullable=False)
request = db.Column(db.Text)
org = db.Column(db.String(255))
teacher_name = db.Column(db.String(255), nullable=False)
material = db.Column(db.String(255))
check_status = db.Column(db.Enum('待审核', '审核通过', '审核失败'), nullable=False)
note = db.Column(db.Text)
verifier_name = db.Column(db.String(255))
building = db.Column(db.String(255))
floor = db.Column(db.Integer)
room_name = db.Column(db.String(255), default="不指定")
class Order(Dictifiable, db.Model):
id = Column(Integer, Sequence('order_id_seq'), primary_key=True)
rp_order_id = Column(String(255), nullable=True, unique=True)
status = Column(db.Enum(OrderStatusTypes),
default=OrderStatusTypes.created,
nullable=False)
# cost of order minus promo code (if any)
amount = Column(DECIMAL(precision=10), nullable=False)
promo_code_id = Column(ForeignKey('promo_code.id'), nullable=True)
user_id = Column(Integer, ForeignKey('user.id'), nullable=False)
create_date = Column(DateTime, default=datetime.utcnow, nullable=False)
update_date = Column(DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
promo_code = relationship('PromoCode', back_populates='orders')
user = relationship('User', back_populates='orders')
tests = relationship('Test',
secondary='order_test',
back_populates='orders')
courses = relationship('Course',
secondary='order_course',
back_populates='orders')
class CITypeRelation(db.Model):
__tablename__ = "ci_type_relations"
ctr_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
parent_id = db.Column(db.Integer,
db.ForeignKey("ci_types.type_id"),
primary_key=True)
parent = db.relationship(
"CIType", primaryjoin="CIType.type_id==CITypeRelation.parent_id")
child_id = db.Column(db.Integer,
db.ForeignKey("ci_types.type_id"),
primary_key=True)
child = db.relationship(
"CIType", primaryjoin="CIType.type_id==CITypeRelation.child_id")
relation_type = db.Column(db.String(7),
db.Enum("contain",
"connect",
"deploy",
"install",
name="relation_type"),
default="contain")
__table_args__ = (db.UniqueConstraint("parent_id",
"child_id",
name="parent_child_uniq"), )
class CIRelationHistory(db.Model):
__tablename__ = "relation_histories"
rh_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
operate_type = db.Column(db.Enum("add", "delete", name="operate_type"))
record_id = db.Column(db.Integer,
db.ForeignKey("records.record_id"),
nullable=False)
first_ci_id = db.Column(db.Integer)
second_ci_id = db.Column(db.Integer)
relation_type = db.Column(
db.Enum("connect",
"deploy",
"install",
"contain",
name="relation_type"))
relation = db.Column(db.Integer, nullable=False)
class Operations(db.Model):
__tablename__ = 'operations'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Enum("read", "write", "create", "delete"), name="name")
def save(self):
db.session.add(self)
db.session.commit()
class Payment(db.Model):
id = db.Column(db.String(32),
primary_key=True,
unique=True,
nullable=False)
user_id = db.Column(db.Integer, nullable=False)
amount = db.Column(DECIMAL(precision=6, scale=2, unsigned=True),
nullable=False)
status = db.Column(db.Enum(PaymentStatus), nullable=False)
class MonsterType(db.Model):
__tablename__ = 'monster_types'
id = db.Column(db.Integer, primary_key=True)
value = db.Column(db.Enum('effect', 'flip', 'fusion', 'gemini', 'link', 'normal', 'pendulum', 'ritual', 'spirit', 'synchro', 'token', 'toon', 'tuner', 'union', 'xyz', name='monster_type'), unique=True, nullable=False)
def __init__(self, value):
self.value = value
def __repr__(self):
return self.value
class CI(db.Model):
__tablename__ = "cis"
ci_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
uuid = db.Column(db.String(32), nullable=False)
type_id = db.Column(db.Integer,
db.ForeignKey("ci_types.type_id"),
nullable=False)
ci_type = db.relationship("CIType", backref="cis")
status = db.Column(db.Enum("review", "validate", name="status"))
created_time = db.Column(db.DateTime, default=datetime.datetime.now())
heartbeat = db.Column(db.DateTime, default=datetime.datetime.now())
class Banlist(db.Model):
__tablename__ = 'banlists'
id = db.Column(db.Integer, primary_key=True)
start_date = db.Column(db.Date, nullable=False)
end_date = db.Column(db.Date)
game_type = db.Column(db.Enum('Advanced', 'Traditional', name='game_type'))
region = db.Column(db.Enum('TCG', 'OCG', name='region'), nullable=False)
bans = db.relationship('Ban', backref='banlist')
__table_args__ = (db.UniqueConstraint('start_date', 'game_type', 'region'),)
def __init__ (self, start_date, end_date, game_type, region):
self.start_date = start_date
self.end_date = end_date
self.game_type = game_type
self.region = region
def __repr__(self):
return "<Banlist {0} / {1} - {2} - {3}>".format(self.start_date, self.end_date, self.game_type, self.region)
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True, unique=True, nullable=False)
user_id = db.Column(db.Integer, nullable=False)
start_time = db.Column(db.DateTime(), nullable=True)
end_time = db.Column(db.DateTime(), nullable=True)
code = db.Column(db.Text(), nullable=False)
shots = db.Column(db.Integer, nullable=False)
schema = db.Column(db.Text(), nullable=True)
status = db.Column(db.Enum(TaskStatusEnum), nullable=False)
response = db.Column(db.JSON(), nullable=True)
cost = db.Column(DECIMAL(precision=6, scale=2,
unsigned=True), nullable=True)
class CIAttributeHistory(db.Model):
__tablename__ = "histories"
h_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
operate_type = db.Column(
db.Enum("add", "delete", "update", name="operate_type"))
record_id = db.Column(db.Integer,
db.ForeignKey("records.record_id"),
nullable=False)
ci_id = db.Column(db.Integer, nullable=False)
attr_id = db.Column(db.Integer, nullable=False)
old = db.Column(db.Text)
new = db.Column(db.Text)
class TestPackage(Dictifiable, db.Model):
"""
Package_id - FK with Package Table
test_id - FK with Test table
"""
__tablename__ = 'test_package'
id = Column(Integer, primary_key=True)
package_id = Column(Integer, ForeignKey('package.id'))
test_id = Column(Integer, ForeignKey('test.id'))
component_type = Column(db.Enum(Type), nullable=False, default=Type.MOCK_TEST)
component_id = Column(Integer)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String, nullable=False)
email = db.Column(db.String, unique=True, nullable=False)
client_id = db.Column(db.Integer, nullable=False)
state = db.Column(db.Enum(States), nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
def __init__(self, username, email, client_id, state):
self.username = username
self.email = email
self.client_id = client_id
self.state = state
self.created_at = datetime.now()
class CorporateApplicants(Dictifiable, db.Model):
__tablename__ = 'corporate_applicants'
user_id = Column(Integer, ForeignKey('user.id'), primary_key=True)
corporate_id = Column(Integer,
ForeignKey('corporate.id'),
primary_key=True)
type = Column(db.Enum(ApplicationStatusTypes), nullable=True)
date = Column(DateTime, default=datetime.utcnow)
user = db.relationship("User", back_populates="application")
corporate = db.relationship("Corporate",
back_populates="corporate_applicants")
class CIAttribute(db.Model):
__tablename__ = "ci_attributes"
attr_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
attr_name = db.Column(db.String(32), nullable=False, unique=True)
attr_alias = db.Column(db.String(32), nullable=False, unique=True)
value_type = db.Column(
db.String(8),
db.Enum("int", "float", "text", "datetime", name='value_type'),
default="text",
nullable=False)
is_choice = db.Column(db.Boolean, default=False)
is_multivalue = db.Column(db.Boolean, default=False)
is_uniq = db.Column(db.Boolean, default=False)
is_index = db.Column(db.Boolean, default=False)
class Card(db.Model):
__tablename__ = 'cards'
id = db.Column(db.Integer, primary_key=True)
codepass = db.Column(db.String, nullable=False)
name = db.Column(db.String, nullable=False)
text = db.Column(db.String, nullable=False)
illegal = db.Column(db.Boolean, nullable=False)
has_name_condition = db.Column(db.Boolean, nullable=False)
type = db.Column(db.Enum('monster', 'spell', 'trap'), nullable=False)
rarities = db.relationship('Rarity', backref='cards', lazy=True)
archetypes = db.relationship("Archetype", secondary=cardsarchetypes, back_populates="cards")
__mapper_args__ = {'polymorphic_on': type}
class UserDayCampusPreference(ModelBase):
__tablename__ = 'user_day_campus_preference'
user_id = db.Column(db.Integer(), db.ForeignKey('app_user.id', onupdate='CASCADE', ondelete='CASCADE'),
primary_key=True)
day = db.Column(db.Enum(Day), primary_key=True)
campus_id = db.Column(db.Integer(), db.ForeignKey('campus.id', onupdate='CASCADE', ondelete='CASCADE'),
nullable=False)
# FIXME: Move this out of this table and instead store this in some subscription info table for daily_menu channel
active = db.Column(db.Boolean(), default=True, nullable=False)
def __init__(self, user_id: int, day: Day, campus_id: int, active=True) -> None:
if not isinstance(user_id, int):
raise expected('user_id', user_id, int)
if not isinstance(day, Day):
raise expected('day', day, Day)
if not isinstance(campus_id, int):
raise expected('campus_id', campus_id, int)
if not isinstance(active, bool):
raise expected('active', active, bool)
self.user_id = user_id
self.day = day
self.campus_id = campus_id
self.active = active
@staticmethod
def get_all_for_user(user: '******') -> 'List[UserDayCampusPreference]':
return UserDayCampusPreference.query.filter_by(user_id=user.id).all()
@staticmethod
def get_for_user(user: '******', day: Day) -> 'Optional[UserDayCampusPreference]':
return UserDayCampusPreference.query.filter_by(user_id=user.id, day=day).first()
@staticmethod
def create(user: '******', day: Day, campus: Campus, active=True) -> 'Optional[UserDayCampusPreference]':
if day in [Day.SATURDAY, Day.SUNDAY]:
raise ValueError('Day cannot be SATURDAY or SUNDAY')
subscription = UserDayCampusPreference(user.id, day, campus.id, active)
db.session.add(subscription)
return subscription
def __hash__(self):
return hash((self.user_id, self.day))
class TrapCard(Card):
__tablename__ = 'traps'
trap_family = db.Column(db.Enum('continuous', 'counter', 'normal', name='family'))
__mapper_args__ = {'polymorphic_identity': 'trap'}
def __init__(self, codepass, name, text, image, thumbnail, illegal, has_name_condition, trap_family):
self.codepass = codepass
self.name = name
self.text = text
self.image = image
self.thumbnail = thumbnail
self.illegal = illegal
self.has_name_condition = has_name_condition
self.trap_family = trap_family
class NetworkProvider(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), nullable=False)
email = db.Column(db.String, nullable=False)
address = db.Column(db.String(200), nullable=False)
contact = db.Column(db.Integer, nullable=False)
pin_code = db.Column(db.Integer, nullable=False, index=True)
website = db.Column(db.String(50), nullable=False)
type = db.Column(db.Enum(ProviderTypeEnum), nullable=False)
def __repr__(self):
return self.name
@staticmethod
def find_by_pin_code(pin_code):
return NetworkProvider.query.filter_by(pin_code=pin_code)
class SpellCard(Card):
__tablename__ = 'spells'
spell_family = db.Column(db.Enum('continuous', 'quick-play', 'normal', 'equip', 'field', 'ritual', name='family'))
__mapper_args__ = {'polymorphic_identity': 'spell'}
def __init__ (self, codepass, name, text, image, thumbnail, illegal, has_name_condition, spell_family):
self.codepass = codepass
self.name = name
self.text = text
self.image = image
self.thumbnail = thumbnail
self.illegal = illegal
self.has_name_condition = has_name_condition
self.spell_family = spell_family
class Package(Dictifiable, db.Model):
"""
Package Name, Description, Type, Price & is_active - Self explanatory
link_id - Additional linkage currently only for COLLEGE ID
"""
__tablename__ = 'package'
id = Column(Integer, primary_key=True)
package_name = Column(String(50))
package_description = Column(String(50))
package_type = Column(db.Enum(PackageTypes),
nullable=False,
default=PackageTypes.COLLEGE)
link_id = Column(Integer)
price = Column(Integer)
is_active = Column(Boolean, default=False, nullable=False)
tests = relationship("TestPackage")
class PaymentModel(db.Model):
__tablename__ = 'payment'
id = db.Column(db.Integer, primary_key=True)
payment_method = db.Column(db.String(100), nullable=False)
reference_id = db.Column(db.String(100), nullable=False)
transaction_id = db.Column(db.String(100), nullable=False)
amount = db.Column(db.Integer, nullable=False)
status = db.Column(db.Enum(PaymentStatus), nullable=False)
@classmethod
def get_by_id(cls, id):
return cls.query.filter_by(id=id).first()
def delete(self):
db.session.delete(self)
db.session.commit()
def save(self):
db.session.add(self)
db.session.commit()
class DocsInfo(db.Model):
__tablename__ = "docs_info"
d_id = db.Column(db.SmallInteger,
primary_key=True,
nullable=False,
autoincrement=True)
group_id = db.Column(db.SmallInteger,
db.ForeignKey("doc_relation.d_id"),
primary_key=True)
title = db.Column(db.String(256), nullable=False)
keys = db.Column(db.String(256))
url = db.Column(db.Text(), nullable=True)
docs_type = db.Column(db.Enum('PDF', 'URL', 'HTML', 'DOC'))
version = db.Column(db.String(6), nullable=False)
author = db.Column(db.String(32), nullable=False)
input_time = db.Column(db.DateTime(), nullable=False)
update_time = db.Column(db.DateTime(), nullable=False)
comment = db.Column(db.Text())
hits = db.Column(db.Integer())
details = db.Column(LONGTEXT)
doc_md5 = db.Column(db.String(32))
class User(UserMixin, ResourceMixin, db.Model):
ROLE = OrderedDict([
('member', 'Member'),
('admin', 'Admin')
])
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=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='')
# 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))
def __init__(self, **kwargs):
# Call Flask-SQLAlchemy's constructor.
super(User, self).__init__(**kwargs)
self.password = User.encrypt_password(kwargs.get('password', ''))
@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 blueprints.user.tasks import deliver_password_reset_email
deliver_password_reset_email.delay(u.id, reset_token)
return u
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
if self.current_sign_in_on == None:
self.last_sign_in_on = self.current_sign_in_on
else:
self.last_sign_in_on = self.current_sign_in_on.replace(
tzinfo=pytz.utc) # TODO: 確認時區設定是否正確
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()
