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)