class CourtCase(db.Model):
cin = db.Column(db.Integer, primary_key=True)
defendent_name = db.Column(db.String(100), nullable=False)
defendent_address = db.Column(db.String(500), nullable=False)
crime_type = db.Column(db.String(10), nullable=False)
crime_date = db.Column(db.DateTime, nullable=False)
crime_location = db.Column(db.String(500), nullable=False)
arresting_officer_name = db.Column(db.String(100), nullable=False)
date_of_arrest = db.Column(db.DateTime(), nullable=False)
judge_name = db.Column(db.String(100), nullable=False)
public_prosecutor_name = db.Column(db.String(100), nullable=False)
starting_date = db.Column(db.DateTime(), nullable=False)
expected_completion_date = db.Column(db.DateTime(), nullable=False)
hearing_date = db.Column(db.DateTime(
)) #Will be constantly updated with the upcoming hearing date
hearing_slot = db.Column(db.Integer) #Same for the slot
hearing_details = db.Column(
db.Text
) # New Adjournment reasons and summary will be appended to the end of this field
latest_adjournment_date = db.Column(db.DateTime,
nullable=True,
default=datetime.datetime(1990, 1, 1))
latest_adjournment_slot = db.Column(db.Integer, nullable=True)
summary = db.Column(db.Text, nullable=True)
is_closed = db.Column(db.Boolean, default=False)
def __repr__(self):
return f"Case Details : '{self.cin}' '{self.hearing_date}' '{self.hearing_slot}'"
class Snippet(db.Model, Serializer):
"""A code snippet"""
__tablename__ = 'snippets'
__public__ = ('id', 'code', 'title', 'language', 'created_at',
'updated_at')
id = db.Column(db.String, primary_key=True, unique=True)
code = db.Column(db.Text)
title = db.Column(db.Text)
language = db.Column(db.Text)
created_at = db.Column(db.DateTime())
updated_at = db.Column(db.DateTime())
def __init__(self, title, language, code):
self.id = uuid.uuid4().hex
self.title = title
self.language = language
self.code = code
self.created_at = datetime.now()
self.updated_at = datetime.now()
def update_code(self, code):
self.code = code
self.updated_at = datetime.now()
def __repr__(self):
return '<Snippet [{}]: {}>'.format(self.id, self.title)
class UnitpayPayments(db.Model):
__tablename__ = 'unitpay_payments'
id = db.Column(db.Integer(),
primary_key=True,
autoincrement=True,
nullable=False)
unitpay_id = db.Column(db.VARCHAR(255), nullable=False)
account = db.Column(db.VARCHAR(255), nullable=False)
sum = db.Column(db.REAL(), nullable=False)
payment_type = db.Column(db.VARCHAR(255), nullable=False)
payer_currency = db.Column(db.VARCHAR(255), nullable=False)
signature = db.Column(db.VARCHAR(100), nullable=False)
date_create = db.Column(db.DateTime(),
nullable=False,
default=datetime.now())
date_complete = db.Column(db.DateTime(), nullable=True, default=None)
status = db.Column(db.Integer(), nullable=False, default=0)
profit = db.Column(db.VARCHAR(255), nullable=True)
def __init__(self, unitpay_id, account, sum, payment_type, payer_currency,
signature, profit):
self.unitpay_id = unitpay_id
self.account = account
self.sum = sum
self.payment_type = payment_type
self.payer_currency = payer_currency
self.signature = signature
self.profit = profit
class BaseModel(object):
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
created_at = Column(db.DateTime(), server_default=func.now(), comment="创建时间")
updated_at = Column(db.DateTime(), server_default=db.text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"),
comment="更新时间")
def to_dict(self):
return {c.name: getattr(self, c.name, None) for c in self.__table__.columns}
class ContactRelCampaign(db.Model):
id = db.Column(db.Integer, primary_key=True)
campaign_id = db.Column(db.Integer)
contact_id = db.Column(db.Integer)
sent_date = db.Column(db.DateTime())
clicked_date = db.Column(db.DateTime())
def __init__(self, campaign_id, contact_id):
self.campaign_id = campaign_id
self.contact_id = contact_id
def __repr__(self):
return f'campaign_id: ${self.campaign_id} - contact_id ${self.contact_id}'
class CustomList(db.Model):
query_class = CustomListQUery
search_vector = db.Column(TSVectorType('name'))
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(64))
owner_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
items = relationship('CustomListItem',
cascade='all, delete-orphan',
backref='list')
creation_ts = db.Column(db.DateTime(), default=datetime.utcnow)
description = db.Column(db.String(256))
private = db.Column(db.Boolean(), default=False)
def get_list_details(self):
ret = {
'name': self.name,
'list_id': self.id,
'creation_ts': self.creation_ts,
'private': self.private,
'items': []
}
for item in self.items:
ret['items'].append({
'title': item.movie.title,
'ordering': item.ordering,
'notes': item.notes
})
ret['num_items'] = len(ret['items'])
return ret
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
def __str__(self):
return self.email
# Create customized model view class
class MyModelView(sqla.ModelView):
def is_accessible(self):
return (current_user.is_active and current_user.is_authenticated
and current_user.has_role('superuser'))
def _handle_view(self, name, **kwargs):
"""
Override builtin _handle_view in order to redirect users when a view is not accessible.
"""
if not self.is_accessible():
if current_user.is_authenticated:
# permission denied
abort(403)
else:
# login
return redirect(url_for('security.login', next=request.url))
class Payment(base.BaseModel):
__tablename__ = 'payments'
id = db.Column(db.Integer, primary_key=True)
item = db.Column(db.String())
amount = db.Column(db.String())
paid_at = db.Column(db.String())
paid = db.Column(db.Boolean())
approved = db.Column(db.Boolean())
assigned_user = db.Column(db.Integer())
receipt_id = db.Column(db.Integer())
assigned_by = db.Column(db.Integer())
assigned_at = db.Column(db.DateTime())
def __init__(self, item, amount, paid_at, paid, approved, assigned_user, receipt_id, assigned_by, assigned_at):
self.item = item
self.amount = amount
self.paid_at = paid_at
self.paid = paid
self.approved = approved
self.assigned_user = assigned_user
self.receipt_id = receipt_id
self.assigned_by = assigned_by
self.assigned_at = assigned_at
def __repr__(self):
return f"<Item {self.item}>"
class Comment(db.Model):
id = db.Column(db.Integer(), primary_key=True)
host_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
author_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
timestamp = db.Column(db.DateTime(), default=datetime.utcnow)
body = db.Column(db.String(512))
class SlotList(db.Model):
id = db.Column(db.Integer, primary_key=True)
cin = db.Column(db.Integer, nullable=False)
date_of_hearing = db.Column(db.DateTime(), nullable=False)
slot_of_hearing = db.Column(
db.Integer, nullable=False
) #SQLAlchemy does not support checking of constraints. We need to do this ourselves
def __repr__(self):
return f"Hearing Date : '{self.date_of_hearing}||'{self.slot_of_hearing} CIN : '{self.cin}"
class HashToken(db.Model):
"""Table for hash tokens."""
__tablename__ = "hashtoken"
htk_id = db.Column(db.String(255), primary_key=True, nullable=False)
htk_tsk_id = db.Column(db.Integer(), db.ForeignKey("task.tsk_id"))
htk_usr_id = db.Column(db.Integer(), db.ForeignKey("user.usr_id"))
htk_locked = db.Column(db.Boolean(), nullable=False, server_default="0")
htk_auth = db.Column(db.String(64))
htk_pin = db.Column(db.String(255))
htk_creation_date = db.Column(db.DateTime())
class Log(db.Model):
"""Table fo logs"""
__tablename__ = "log"
log_id = db.Column(db.Integer, primary_key=True)
log_type = db.Column(db.String(64), index=True, nullable=True)
log_msg = db.Column(db.String(1000), nullable=True)
log_timestamp = db.Column(db.DateTime(),
nullable=False,
default=datetime.datetime.utcnow)
log_usr_id = db.Column(db.Integer(), db.ForeignKey("user.usr_id"))
log_tsk_id = db.Column(db.Integer(), db.ForeignKey("task.tsk_id"))
class UserModel(db.Model, ModelMixin):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255))
created_on = db.Column(db.DateTime(timezone=True))
user_logins = db.relationship('UserLogins',
backref='UserModel',
lazy='subquery')
__table_args__ = (db.UniqueConstraint('username'), )
class User(db.Model):
"""Table fo users"""
__tablename__ = "user"
usr_id = db.Column(db.Integer, primary_key=True)
usr_name = db.Column(db.String(64), index=True, unique=True)
usr_email = db.Column(db.String(255), index=True, unique=True)
usr_email_confirmed_at = db.Column(db.DateTime(), nullable=True)
usr_phone = db.Column(db.String(64), index=True)
usr_role = db.Column(db.String(64), index=True)
usr_hash_tokens = db.relationship('HashToken', backref='user', lazy=True)
log_list = db.relationship('Log', backref='user', lazy=True)
def __repr__(self):
return '<User {}>'.format(self.usr_name)
class Task(db.Model):
"""Table fo tasks"""
__tablename__ = "task"
tsk_id = db.Column(db.Integer, primary_key=True)
tsk_fault_description = db.Column(db.String(1000))
tsk_creation_date = db.Column(db.DateTime())
tsk_state = db.Column(db.String(64), db.ForeignKey("state.sta_name"))
tsk_next_step = db.Column(db.String(64), db.ForeignKey("step.ste_name"))
#tsk_hash_token = db.Column(db.String(255), nullable=False)
tsk_cus_id = db.Column(db.Integer(), db.ForeignKey("customer.cus_id"))
tsk_dev_id = db.Column(db.Integer(), db.ForeignKey("device.dev_id"))
tsk_supervisor_usr_id = db.Column(db.Integer(),
db.ForeignKey("user.usr_id"))
tsk_acc_name = db.Column(db.String(255),
db.ForeignKey("accessory.acc_name"))
hash_tokens = db.relationship('HashToken', backref='task', lazy=True)
log_list = db.relationship('Log', backref='task', lazy=True)
class Document(base.BaseModel):
__tablename__ = 'documents'
id = db.Column(db.Integer, primary_key=True)
receipt_desc = db.Column(db.String())
uploaded_by = db.Column(db.Integer())
group_id = db.Column(db.Integer())
document_id = db.Column(db.String())
timestamp = db.Column(db.DateTime())
def __init__(self, receipt_desc, uploaded_by, group_id, document_id,
timestamp):
self.receipt_desc = receipt_desc
self.uploaded_by = uploaded_by
self.group_id = group_id
self.document_id = document_id
self.timestamp = timestamp
def __repr__(self):
return f"<Document: {self.document_id}>"
class Transaction(db.Model):
"""
Transactions that are done between wallets are stored by this model.
"""
__tablename__ = "transactions"
id = db.Column(db.Integer, primary_key=True)
at = db.Column(db.DateTime())
sender = db.Column(db.Integer,
db.ForeignKey("wallets.id", ondelete="SET NULL"))
receiver = db.Column(db.Integer,
db.ForeignKey("wallets.id", ondelete="SET NULL"))
amount = db.Column(db.Float, nullable=False)
currency = db.Column(db.String(16), nullable=False)
isapproved = db.Column(db.Boolean, default=True)
@property
def serialize(self):
"""
returns a JSON serializable representation of a Transaction
"""
sender = None
receiver = None
if self.sender is not None:
sender = Wallet.query.get(self.sender).owner.serialize
if self.receiver is not None:
receiver = Wallet.query.get(self.receiver).owner.serialize
return {
"id": self.id,
"sender": sender,
"receiver": receiver,
"amount": self.amount,
"currency": self.currency,
"isapproved": self.isapproved
}
def __repr__(self):
return f"Transaction({self.sender}, {self.receiver}, {self.amount})"
class Artist(db.Model):
__tablename__ = 'artists'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(45), unique=True)
birth_year = db.Column(db.Integer)
death_year = db.Column(db.Integer)
country = db.Column(db.String(45))
genre = db.Column(db.String(45))
images = db.relationship(
'Image',
backref=db.backref('artist'),
)
created_at = db.Column(db.DateTime(timezone=False))
updated_at = db.Column(db.DateTime(timezone=False))
def __init__(self, **artist_info):
self.name = artist_info.get('name')
self.country = artist_info.get('country')
self.genre = artist_info.get('genre')
self.birth_year = artist_info.get('birth_year')
self.death_year = artist_info.get('death_year')
self.created_at = datetime.now()
def __repr__(self):
return '<Artist: {}>'.format(self.name)
@classmethod
def filter_by_params(cls, params):
query = cls.query
if 'name' in params:
query = cls.filter_by_name(query, params['name'])
if 'country' in params:
query = cls.filter_by_country(query, params['country'])
if 'genre' in params:
query = cls.filter_by_genre(query, params['genre'])
if 'alive_in' in params:
query = cls.filter_by_alive_in(query, params['alive_in'])
if 'order' in params:
query, error = cls.filter_by_order(query, params['order'])
if error: return None, error
if 'max_items' in params:
query = cls.filter_by_max_items(query, params['max_items'])
return query.all(), None
@classmethod
def filter_by_name(cls, query, name):
return query.filter(cls.name.contains(name))
@classmethod
def filter_by_country(cls, query, country):
return query.filter(cls.country.contains(country))
@classmethod
def filter_by_genre(cls, query, genre):
return query.filter(cls.genre.contains(genre))
@classmethod
def filter_by_alive_in(cls, query, alive_in):
return query.filter(cls.birth_year <= alive_in).\
filter(or_(cls.death_year == None, cls.death_year >= alive_in))
@classmethod
def filter_by_order(cls, query, order):
if not order in ['desc', 'asc']:
return None, unprocessable_entry("order parameter invalid, try desc or asc")
if order == 'desc':
return query.order_by(-cls.created_at), None
return query.order_by(cls.created_at), None
@classmethod
def filter_by_max_items(cls, query, max_items):
if max_items.isdigit():
return query.limit(max_items)
return query
@property
def to_json(self):
return {
'id': self.id,
'name': self.name,
'birth_year': self.birth_year,
'death_year': self.death_year,
'country': self.country,
'genre': self.genre,
}
@property
def to_json_with_detail(self):
data = self.to_json
data['detail_href'] = get_absolute_url('artists_api.artists_detail', artist_id=self.id)
return data
@property
def to_json_with_artworks(self):
data = self.to_json
data['artworks_href'] = get_absolute_url('artists_api.artists_artworks', artist_id=self.id)
return data
class User(db.Model):
query_class = UserQuery
search_vector = db.Column(TSVectorType('username'))
# Account Specific
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(64), unique=True, index=True)
email = db.Column(db.String(128), unique=True)
pw_hash = db.Column(db.String(128), nullable=False)
verified = db.Column(db.Boolean(), default=False)
# Profile Specific
fav_genre = db.Column(db.String(64))
join_date = db.Column(db.Date(), default=date.today)
last_online = db.Column(db.DateTime(), default=datetime.utcnow)
gender = db.Column(db.String(64))
location = db.Column(db.String(64))
website = db.Column(db.String(64))
about = db.Column(db.String(256))
profile_views = db.Column(db.Integer(), default=0)
friends = db.relationship('Friendship',
primaryjoin=id == Friendship.user_id,
lazy='dynamic') # M:M
profile_comments = db.relationship('Comment',
foreign_keys='Comment.host_id') # 1:M
posted_comments = db.relationship('Comment',
foreign_keys='Comment.author_id',
backref='author') # 1:M
flicks_list = db.relationship('FlicksList', backref='owner',
uselist=False) # 1:1
favourites = db.relationship('Favourite') # M:M
custom_lists = db.relationship('CustomList', backref='owner') # 1:M
recommendations = db.relationship('Recommendation',
backref='author') # 1:M
reviews = db.relationship('Review', backref='author') # 1:M
def __init__(self, **kwargs):
super(User, self).__init__(**kwargs)
self.flicks_list = FlicksList(name='Flickslist')
@classmethod
def verify_confirmation_token(cls, token):
serializer = Serializer(current_app.config['SECRET_KEY'])
try:
data = serializer.loads(token)
user_id = data.get('user_id_confirm')
except:
return None
return User.query.get(user_id)
@classmethod
def verify_reset_password_token(cls, token):
serializer = Serializer(current_app.config['SECRET_KEY'])
try:
data = serializer.loads(token)
user_id = data.get('user_id_reset_pass')
except:
return None
return User.query.get(user_id)
def set_password(self, password):
self.pw_hash = bcrypt.generate_password_hash(password).decode('utf-8')
def verify_password(self, password):
return bcrypt.check_password_hash(self.pw_hash, password)
def generate_confirm_token(self):
serializer = Serializer(
current_app.config['SECRET_KEY'],
expires_in=current_app.config['JWT_CONFIRM_TOKEN_EXPIRES'])
return serializer.dumps({'user_id_confirm': self.id}).decode('utf-8')
def generate_reset_password_token(self):
serializer = Serializer(
current_app.config['SECRET_KEY'],
expires_in=current_app.config['JWT_RESET_PASS_TOKEN_EXPIRES'])
return serializer.dumps({
'user_id_reset_pass': self.id
}).decode('utf-8')
def add_friend(self, friend, active=0):
self.friends.append(
Friendship(user_id=self.id, friend_id=friend.id, active=active))
db.session.commit()
def remove_friend(self, friend):
self.friends.remove(friend)
friend.friends.remove(self)
db.session.commit()
class FreeCompany(db.Model):
"""
Free Company which contains at least one :class:`api.models.Character` and its associated stats
Generated and added to DB by :func:`api.scrapers.free_company.scrape_free_company`.
"""
id = db.Column(db.String(200), primary_key=True, unique=True)
"""
Numeric ID unique for each free company
Used to scrape the free company's info from Lodestone, see below.
.. image:: ../../images/free_company_lodestone_id.PNG
:type: String
"""
name = db.Column(db.String(100))
"""
:type: String
"""
server = db.Column(db.String(100))
"""
:type: String
"""
members_id = db.relationship('Character',
backref='free_company',
lazy='dynamic')
"""
Members of the free company
:type: :class:`api.models.Character`
"""
tag = db.Column(db.String(20))
"""
:type: String
"""
formed = db.Column(db.DateTime())
"""
:type: DateTime
"""
rank = db.Column(db.Integer)
"""
Reward rank (max 8). See `wiki <http://ffxiv.consolegameswiki.com/wiki/Free_Company#Free_Company_Entitlements>`_.
:type: Int
"""
weekly_rank = db.Column(db.Integer)
"""
World standings (previous week)
:type: Int
"""
monthly_rank = db.Column(db.Integer)
"""
World standings (previous month)
:type: Int
"""
slogan = db.Column(db.String(200))
"""
:type: String
"""
@property
def as_dict(self):
"""
:return: Dictionary of the the class' values for easier JSON serialization
"""
return {
'lodestone_id': self.id,
'name': self.name,
'server': self.server,
'tag': self.tag,
'date_formed': self.formed,
'rank': self.rank,
'weekly_rank': self.weekly_rank,
'monthly_rank': self.monthly_rank,
'slogan': self.slogan
}
def __repr__(self):
return '<FreeCompany name={} id={}>'.format(self.name, self.id)