class UserRequest(db.Model): """Define the UserRequest data-model""" __tablename__ = 'user_requests' id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE')) authorizer_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE')) request_date = db.Column(db.DateTime()) auth_date = db.Column(db.DateTime()) start_date = db.Column(db.DateTime()) end_date = db.Column(db.DateTime()) request_type_id = db.Column( db.Integer(), db.ForeignKey('request_types.id', ondelete='CASCADE')) prv_note_to_auth = db.Column(db.UnicodeText(255), server_default='') prv_note_from_auth = db.Column(db.UnicodeText(255), server_default='') pub_note = db.Column(db.UnicodeText(255), server_default='') authorized = db.Column('is_authorized', db.Boolean(), nullable=False, server_default='0') # Define relationships to User user = db.relationship('User', backref='requests', foreign_keys=[user_id]) authorizer = db.relationship('User', backref='authorizations', foreign_keys=[authorizer_id]) # Define relationship to RequestType request_type = db.relationship('RequestType', backref='user_requests') # Define relationship to Allowance allowance = db.relationship( 'Allowance', primaryjoin= 'and_(foreign(UserRequest.user_id) == remote(Allowance.user_id), foreign(UserRequest.request_type_id) == remote(Allowance.request_type_id))', backref='user_requests')
class AssociationCourseGroup(db.Model): __tablename__ = 'Course_X_Group' course_id = db.Column(db.Integer, db.ForeignKey('EducationalСourse.id'), primary_key=True) group_id = db.Column(db.Integer, db.ForeignKey('EducationalGroup.id'), primary_key=True) extra_data = db.Column(db.String(50)) is_active = db.Column(db.Integer, nullable=False, default = 0) created_on = db.Column(db.DateTime(), default=datetime.utcnow) updated_on = db.Column(db.DateTime(), default=datetime.utcnow, onupdate=datetime.utcnow) child = db.relationship("EducationalGroup", back_populates="parents") parent = db.relationship("EducationalCourse", back_populates="children") def __init__(self, course_id:int, group_id:int, is_active = 1, extra_data = ''): self.course_id = course_id self.group_id = group_id self.is_active = is_active self.extra_data = extra_data """ Many-to-Many association between courses and groups Firstly, check: Is association exist? -> Exists: Update optional parametrs -> Doesn't exist: Create new association with all available parametrs """ def associate_course_with_group(self): association = db.session.query(AssociationCourseGroup).filter(AssociationCourseGroup.course_id == self.course_id).filter(AssociationCourseGroup.group_id == self.group_id).first() if association != None: if (self.is_active != association.is_active): association.is_active = self.is_active db.session.commit() if (self.extra_data != association.extra_data): association.extra_data = self.extra_data db.session.commit() else: db.session.add(self) db.session.commit()
class CourseHometask(db.Model): __tablename__ = 'course_hometask' id = db.Column(db.Integer, nullable = False, primary_key=True) course_id = db.Column(db.Integer(), db.ForeignKey('EducationalСourse.id'), nullable = False ) name = db.Column(db.String(100), nullable = False) content = db.Column(db.String(10000), nullable = False) start_dttm = db.Column(db.DateTime(), nullable = False) end_dttm = db.Column(db.DateTime(), nullable = False) created_on = db.Column(db.DateTime(), default=datetime.utcnow) updated_on = db.Column(db.DateTime(), default=datetime.utcnow, onupdate=datetime.utcnow) deleted = db.Column(db.Integer() ) def __init__(self, course_id, name, content, start_dttm, end_dttm): self.course_id = course_id self.name = name self.content = content self.start_dttm = start_dttm self.end_dttm = end_dttm self.deleted = 0 def set_content(self, content): self.content = content def delete(self): self.deleted = 1 def __repr__(self): return "<CourseHometask Info {}:{}:{}>".format(self.id, self.course_id, self.name)
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(64), index=True, unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) active = db.Column(db.Boolean(), default=True) confirmed_at = db.Column(db.DateTime()) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(45)) current_login_ip = db.Column(db.String(45)) login_count = db.Column(db.Integer) roles = db.relationship('Role', secondary="roles_users", backref=db.backref('users', lazy='dynamic')) chats = db.relationship('Chat', secondary="chat_users", backref="chats", lazy='dynamic') def __repr__(self): return '<User %r>' % (self.email) def get_id(self): try: return unicode(self.id) # python 2 except NameError: return str(self.id) # python 3
class User(db.Model): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255), unique=True) username = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) deleted = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) first_name = db.Column(db.String(255)) last_name = db.Column(db.String(255)) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(100)) current_login_ip = db.Column(db.String(100)) login_count = db.Column(db.Integer) # roles = db.relationship('Role', secondary='roles_users', # backref=db.backref('users', lazy='dynamic')) def gravatar(self, size=64, consider_settings=True): parameters = {'s': str(size), 'd': 'mm'} return "https://www.gravatar.com/avatar/" + \ hashlib.md5(self.email.lower()).hexdigest() + \ "?" + urllib.urlencode(parameters) def __str__(self): return self.email
class Trip(db.Model): """Define schema for trip table """ id = db.Column(db.Integer, primary_key=True, doc='id da viagem') start_date = db.Column(db.DateTime(timezone=True), nullable=False, index=True, default=db.func.now(), doc='Data início da viagem') end_date = db.Column(db.DateTime(timezone=True), nullable=False, index=True, default=db.func.now(), doc='Data fim da viagem') classification = db.Column(types.Enum(EnumBikeTripType, name='enum_bike_trip_type'), nullable=True, doc=u'Classificacão da viagem') score = db.Column(db.Integer(), nullable=True, doc='Nota da viagem') user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False, doc='ID do usuário que realizou a viagem') user = db.relationship('User', doc='Instancia de User')
class FlicketPost(Base): __tablename__ = 'flicket_post' id = db.Column(db.Integer, primary_key=True) ticket_id = db.Column(db.Integer, db.ForeignKey(FlicketTicket.id)) ticket = db.relationship(FlicketTicket, back_populates='posts') content = db.Column(db.String(field_size['content_max_length'])) user_id = db.Column(db.Integer, db.ForeignKey(FlicketUser.id)) user = db.relationship(FlicketUser, foreign_keys='FlicketPost.user_id') date_added = db.Column(db.DateTime()) date_modified = db.Column(db.DateTime()) modified_id = db.Column(db.Integer, db.ForeignKey(FlicketUser.id)) modified = db.relationship(FlicketUser, foreign_keys='FlicketPost.modified_id') # finds all the images associated with the post uploads = db.relationship( 'FlicketUploads', primaryjoin="and_(FlicketPost.id == FlicketUploads.posts_id)") # finds all the actions associated with the post actions = db.relationship( 'FlicketAction', primaryjoin="and_(FlicketPost.id == FlicketAction.post_id)")
class User(UserMixin, db.Model): def __init__(self, id, first_name='', uuid='', practice_uuid='', practice_name='', practice_id='', practice_admin='', invoice_layout = '', namaf_profession = '', practice_role='', practice_folder_id='', active=True): self.uuid = uuid self.first_name = first_name self.practice_uuid = practice_uuid self.practice_name = practice_name self.practice_id = practice_id self.practice_admin = practice_admin self.invoice_layout = invoice_layout self.namaf_profession = namaf_profession self.practice_role = practice_role self.id = id self.practice_folder_id = practice_folder_id self.active = active __tablename__ = 'users' id = db.Column(db.Integer(), primary_key=True) uuid_bin = db.Column(UUIDType(binary=False)) uuid_text = db.Column(db.String(36), nullable=False) title = db.Column(db.String(255), nullable=True) first_name = db.Column(db.String(255), nullable=False) second_name = db.Column(db.String(255), nullable=False) email = db.Column(db.String(100), unique=True) current_practice_uuid = db.Column(db.String(36), nullable=True) current_practice_role = db.Column(db.DateTime, nullable=False) created_on = db.Column(db.DateTime(),default=datetime.utcnow) last_active = db.Column(db.DateTime(),default=datetime.utcnow,onupdate=datetime.utcnow)
class Job(db.Model): """A Job is the basic work unit of Flamenco The creation of a job can happen in different ways: * within Flamenco (using the job creation form) * via a query from an external software (e.g. Attract) * withing Blender itself Possible statuses for a job are: * Waiting (tasks for this job are ready to be dispatched) * Active * Canceled * Failed * Paused (will be added later) * Completed * Waiting """ id = db.Column(db.Integer, primary_key=True) project_id = db.Column(db.Integer, db.ForeignKey('project.id')) project = db.relationship('Project', backref=db.backref('jobs', lazy='dynamic')) name = db.Column(db.String(120)) status = db.Column(db.String(64)) priority = db.Column(db.Integer()) settings = db.Column(db.Text()) creation_date = db.Column(db.DateTime(), default=datetime.datetime.now) date_edit = db.Column(db.DateTime()) type = db.Column(db.String(64)) tasks_status = db.Column(db.String(256)) notes = db.Column(db.Text()) user_id = db.Column(db.Integer(), db.ForeignKey('user.id')) user = db.relationship('User', backref=db.backref('job', lazy='dynamic')) def __repr__(self): return '<Job %r>' % self.name
class FlicketPost(PaginatedAPIMixin, Base): __tablename__ = "flicket_post" id = db.Column(db.Integer, primary_key=True) ticket_id = db.Column(db.Integer, db.ForeignKey(FlicketTicket.id)) ticket = db.relationship(FlicketTicket, back_populates="posts") content = db.Column(db.String(field_size["content_max_length"])) user_id = db.Column(db.Integer, db.ForeignKey(FlicketUser.id)) user = db.relationship(FlicketUser, foreign_keys="FlicketPost.user_id") date_added = db.Column(db.DateTime()) date_modified = db.Column(db.DateTime()) modified_id = db.Column(db.Integer, db.ForeignKey(FlicketUser.id)) modified = db.relationship(FlicketUser, foreign_keys="FlicketPost.modified_id") days = db.Column(db.Numeric(10, 2), server_default="0") # finds all the images associated with the post uploads = db.relationship( "FlicketUploads", primaryjoin="and_(FlicketPost.id == FlicketUploads.posts_id)" ) # finds all the actions associated with the post actions = db.relationship( "FlicketAction", primaryjoin="FlicketPost.id == FlicketAction.post_id" ) def to_dict(self): """ :return: dict() """ data = { "id": self.id, "content": self.content, "data_added": self.date_added, "date_modified": self.date_modified, "ticket_id": self.ticket_id, "user_id": self.user_id, "links": { "self": app.config["base_url"] + url_for("bp_api.get_post", id=self.id), "created_by": app.config["base_url"] + url_for("bp_api.get_user", id=self.user_id), "posts": app.config["base_url"] + url_for("bp_api.get_posts", ticket_id=self.ticket_id), }, } return data def __repr__(self): return "<FlicketPost: id={}, ticket_id={}, content={}>".format( self.id, self.ticket_id, self.content )
class User(db.Model, RoleFreeUserMixin): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(255)) password = db.Column(db.String(255)) active = db.Column(db.Boolean(), default=False) confirmed_at = db.Column(db.DateTime()) user_type = db.Column(db.Enum(TypeOfUser, name="type_of_user_types"), nullable=False) capabilities = db.Column(MutableList.as_mutable(ARRAY(db.String)), default=[]) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(16)) current_login_ip = db.Column(db.String(16)) login_count = db.Column(db.Integer) failed_login_count = db.Column(db.Integer, default=0) # relationships measures = db.relationship( "Measure", lazy="subquery", secondary="user_measure", primaryjoin="User.id == user_measure.columns.user_id", secondaryjoin="Measure.id == user_measure.columns.measure_id", back_populates="shared_with", ) __table_args__ = (UniqueConstraint(email, name="uq_users_email"),) def user_name(self): return self.email.split("@")[0] def is_departmental_user(self): return self.user_type == TypeOfUser.DEPT_USER def is_rdu_user(self): return self.user_type == TypeOfUser.RDU_USER def is_admin_user(self): return self.user_type == TypeOfUser.ADMIN_USER def can(self, capability): return capability in self.capabilities def can_access_measure(self, measure): if self.user_type != TypeOfUser.DEPT_USER: return True else: return self in measure.shared_with # DEPRECATED: use `can_access_measure` method instead. def can_access(self, measure_slug): if self.user_type != TypeOfUser.DEPT_USER: return True else: if any(measure.slug == measure_slug for measure in self.measures): return True else: return False
class Tasks(db.Model): task_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(20), nullable=True) details = db.Column(db.String(100), nullable=True) start_date = db.Column(db.DateTime('%Y-%m-%d %H:%M'), nullable=True) due_date = db.Column(db.DateTime('%Y-%m-%d %H:%M'), nullable=True) end_date = db.Column(db.DateTime('%Y-%m-%d %H:%M'), nullable=True) state = db.Column(db.String(10))
class Caught_by(db.Model): Officer_id = db.Column(db.String(8), db.ForeignKey("police_officers.Officer_id"), primary_key=True) Criminal_id = db.Column(db.Integer(), db.ForeignKey("criminal.Criminal_id"), primary_key=True) Start_date = db.Column(db.DateTime(), default=datetime.utcnow()) End_date = db.Column(db.DateTime())
class Invoice(db.Model): id:int practice_uuid:str patient_id:str medical_aid:str date_created:datetime date_invoice:datetime invoice_id:str invoice_file_url:str tariff:str po_number:int hospital_name:str admission_date:datetime discharge_date:datetime procedure:str procedure_date:str diagnosis:str diagnosis_date:datetime implants:str intra_op:str post_op:str submitted_on:datetime invoice_layout:int status:str credit_cent:int remind_me:datetime last_edited:datetime last_edited_by:str __tablename__ = 'invoices' id = db.Column(db.Integer(), primary_key=True) practice_uuid = db.Column(db.String(36), nullable=False) patient_id = db.Column(db.String(255), nullable=False) medical_aid = db.Column(db.String(255), nullable=False) date_created = db.Column(db.DateTime(),default=datetime.utcnow) date_invoice = db.Column(db.Date(),nullable=False) invoice_id = db.Column(db.String(255),nullable=False) invoice_file_url = db.Column(db.String(255),nullable=False) tariff = db.Column(db.String(255),nullable=False) po_number = db.Column(db.Integer(), nullable=True) hospital_name = db.Column(db.String(255), nullable=True) admission_date = db.Column(db.Date(), nullable=True) discharge_date = db.Column(db.Date(), nullable=True) procedure = db.Column(db.Text(), nullable=True) procedure_date = db.Column(db.Date(), nullable=True) diagnosis = db.Column(db.Text(), nullable=True) diagnosis_date = db.Column(db.Date(), nullable=True) implants = db.Column(db.Text(), nullable=True) intra_op = db.Column(db.String(255), nullable=True) post_op = db.Column(db.String(255), nullable=True) submitted_on = db.Column(db.Date(),nullable=True) invoice_layout = db.Column(db.Integer(), nullable=True) status = db.Column(db.String(255), default="not-submitted") credit_cent = db.Column(db.Integer(), default=0) remind_me = db.Column(db.DateTime, nullable=True) last_edited = db.Column(db.DateTime(),default=datetime.utcnow,onupdate=datetime.utcnow) last_edited_by = db.Column(db.String(255), nullable=True)
class Vote(db.Model): id = db.Column(db.Integer, primary_key=True) date_created = db.Column(db.DateTime(timezone=True), default=db.func.current_timestamp()) date_modified = db.Column(db.DateTime(timezone=True), default=db.func.current_timestamp(), onupdate=db.func.current_timestamp()) poll_id = db.Column(db.Integer, db.ForeignKey('poll.id'), nullable=False) vote_option_id = db.Column(db.Integer, db.ForeignKey('vote_option.id'), nullable=False) @staticmethod def add_account_vote(account_id, poll_id): r = User_voted.query.filter_by(account_id=account_id, poll_id=poll_id).count() if(r > 0): return False r = User_voted() r.account_id = account_id r.poll_id = poll_id db.session.add(r) db.session.commit() return True @staticmethod def admin_top_polls_most_votes(limit=10): stmt = text(""" SELECT t.vote_cnt, poll.id, poll.name, poll.date_open, poll.date_close, account.id, account.firstname, account.lastname FROM ( SELECT count(*) as vote_cnt, poll_id FROM vote GROUP BY poll_id ORDER BY count(*) desc LIMIT :limit ) as t LEFT JOIN poll ON (t.poll_id = poll.id) LEFT JOIN account ON (account.id = poll.owner_id) """).params(limit=limit) return db.engine.execute(stmt) @staticmethod def order66(): res = db.engine.execute("DELETE FROM vote") res = db.engine.execute("DELETE FROM user_voted")
class User(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(100), nullable = False) surname = db.Column(db.String(100), nullable = False) second_name = db.Column(db.String(100), nullable = False) username = db.Column(db.String(50), unique=True) email = db.Column(db.String(100), unique=True) password_hash = db.Column(db.String(100)) registration_password_hash = db.Column(db.String(100)) created_on = db.Column(db.DateTime(), default=datetime.utcnow) updated_on = db.Column(db.DateTime(), default=datetime.utcnow, onupdate=datetime.utcnow) def __init__(self, name, surname, second_name): self.name = name self.surname = surname self.second_name = second_name @staticmethod def create_user(name, surname, second_name): user = User(name, surname, second_name) db_add_objects(user) print('Сначала создали юзера = ', user) user_info = UserInfo(user.id) user_social_pages = UserSocialPages(user.id) db_add_objects(user_info, user_social_pages) print('Затем создали: ',user,' ',user_info,' ',user_social_pages) return user def __repr__(self): return "<{}:{}>".format(self.id, self.name + ' ' + self.surname) def set_username(self, username): self.username = username def set_email(self, email): self.email = email def set_password(self, password): self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def set_registration_password(self, password_length = 10): lettersAndDigits = string.ascii_letters + string.digits registration_password = '' for i in range(password_length): registration_password = registration_password + random.choice(lettersAndDigits) self.registration_password_hash = generate_password_hash(registration_password) return registration_password
class Ticket(db.Model): id = db.Column(db.Integer(), primary_key=True, nullable=False) creation_datetime = db.Column(db.DateTime(), nullable=False, default=datetime.datetime.now) closed_datetime = db.Column(db.DateTime(), nullable=True) title = db.Column(db.String(100), nullable=False) description = db.Column(db.Text(), nullable=True) status_id = db.Column(db.Integer(), db.ForeignKey("status.id"), nullable=False) priority_id = db.Column(db.Integer(),db.ForeignKey("priority.id"), nullable=False) created_by = db.Column(db.Integer(), db.ForeignKey("user.id"), nullable=False) status = relationship("Status") priority = relationship("Priority") ticket_note = relationship("Ticket_Notes")
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) 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()) last_login_at = db.Column(db.DateTime()) current_login_at = db.Column(db.DateTime()) last_login_ip = db.Column(db.String(32)) current_login_ip = db.Column(db.String(32)) login_count = db.Column(db.Integer) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
class Customer(db.Model): id = db.Column(db.Integer, primary_key=True) full_name = db.Column(db.String()) email = db.Column(db.String()) telephone = db.Column(db.String()) date_registered = db.Column(db.DateTime()) bookings = db.relationship("Booking", backref="customer")
class Patient(db.Model): practice_uuid:str patient_id:str patient_name:str medical_aid:str main_member:str patient_birth_date:datetime medical_number:str case_number:str patient_note:str created_on:datetime #updated_on:datetime __tablename__ = 'patients' id = db.Column(db.Integer(), primary_key=True) practice_uuid = db.Column(db.String(36), nullable=False) patient_name = db.Column(db.String(255), nullable=False) medical_aid = db.Column(db.String(255), nullable=False) main_member = db.Column(db.String(255), nullable=True) patient_birth_date = db.Column(db.Date(), nullable=True) medical_number = db.Column(db.String(255), nullable=True) case_number = db.Column(db.String(255), nullable=True) patient_note = db.Column(db.Text, nullable=True) created_on = db.Column(db.DateTime(),default=datetime.utcnow) #updated_on = db.Column(db.DateTime(),default=datetime.utcnow,onupdate=datetime.utcnow) @hybrid_property def patient_id(self): if self.medical_number is not None: return self.medical_number else: return self.case_number @patient_id.expression def patient_id(cls): return case([(cls.case_number != None, cls.case_number),], else_ = cls.medical_number)
class Task(db.Model): """Tasks are created after a Shot is added Tasks can be reassigned individually to a different worker, but can be deleted and recreated all together. A task is made of "orders" or instructions, for example: * Check out SVN revision 1954 * Clean the /tmp folder * Render frames 1 to 5 of scene_1.blend * Send email with results to [email protected] """ id = db.Column(db.Integer, primary_key=True) job_id = db.Column(db.Integer, db.ForeignKey('job.id')) job = db.relationship('Job', backref=db.backref('tasks', lazy='dynamic')) manager_id = db.Column(db.Integer()) name = db.Column(db.String(64)) status = db.Column(db.String(64)) priority = db.Column(db.Integer()) type = db.Column(db.String(64)) settings = db.Column(db.Text()) log = db.Column(db.Text()) activity = db.Column(db.String(128)) child_id = db.Column(db.Integer()) parser = db.Column(db.String(64)) time_cost = db.Column(db.Integer()) last_activity = db.Column(db.DateTime()) # Currently the hostname, later will be a serialized dictionary, storing # id and hostname of a worker worker = db.Column(db.String(128)) def __repr__(self): return '<Task %r>' % self.id
class Question(db.Model): """deployment model""" __tablename__ = 'questions' __table_args__ = {'extend_existing': True} id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String()) question = db.Column(db.String()) function_name = db.Column(db.String()) session = db.Column(db.Integer()) args = db.Column(db.PickleType()) answer = db.Column(db.PickleType()) timeout = db.Column(db.Float()) created_date = db.Column(db.DateTime(), default=datetime.datetime.utcnow) def __init__(self, name, question, function_name, args, answer, timeout, session): self.name = name self.question = question self.function_name = function_name self.answer = answer self.session = session self.args = args self.timeout = timeout def __repr__(self): return '<question {0}, {1}>'.format(self.name, self.id)
class User(db.Model): id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, unique=True, nullable=False) username = db.Column(db.String(64), index=True, unique=True, nullable=False) email = db.Column(db.String(120), index=True, unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) active = db.Column(db.Boolean(), default=True, nullable=False) created = db.Column(db.DateTime(), default=datetime.now(), nullable=False) def __init__(self, username, email, password): self.username = username self.email = email self.password = bcrypt.generate_password_hash( password.encode('utf-8'), current_app.config.get('BCRYPT_LOG_ROUNDS')).decode() def __repr__(self): return '<User {}>'.format(self.id) def to_json(self): return { 'id': self.id, 'username': self.username, 'email': self.email, 'active': self.active, 'created': self.created }
class Day(db.Model): __tablename__ = 'days' id = db.Column(db.Integer(), primary_key=True) date = db.Column(db.DateTime(), default=datetime.datetime.utcnow, nullable=False) habit_id = db.Column(db.Integer(), db.ForeignKey('habits.id')) user_id = db.Column(db.Integer(), db.ForeignKey('users.id')) habit_complete = db.Column(db.Boolean()) #Parent habit = relationship("Habit", back_populates="days") #Child daydescs = relationship("DayDesc", back_populates='day', cascade="all, delete, delete-orphan") def __init__(self, date, habit_id, user_id, habit_complete): self.date = date self.habit_id = habit_id self.user_id = user_id self.habit_complete = habit_complete def __repr__(self): return f'{self.date}:{self.habit_id}:{self.habit_complete}'
class Crime_evidence(db.Model): Case_No = db.Column(db.Integer(), db.ForeignKey("crime.Case_No"), primary_key=True) Description = db.Column(db.String(128)) Collection_date = db.Column(db.DateTime(), default=datetime.utcnow()) location = db.Column(db.String(128))
class User(Base): __tablename__ = "account" username = db.Column(db.String(255), nullable=False, unique=True) password = db.Column(db.String(255), nullable=False) role_id = db.Column(db.Integer, db.ForeignKey('role.id'), nullable=False) date_created = db.Column(db.DateTime(), default=db.func.current_timestamp()) def __init__(self, name, username, password): self.name = name self.username = username self.password = password def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True
class UserLedger(db.Model): """ SQLAlchemy object :: `user_ledgers` table. Fields ------ id : int The primary key and user identifier. user_id : int The user identifier. amount : float Transaction value. timestamp : datetime Timestamp of transaction. """ __tablename__ = "user_ledgers" id = db.Column(db.Integer, primary_key=True) amount = db.Column(db.Float, nullable=False) timestamp = db.Column(db.DateTime(timezone=True), default=func.now()) # relationships user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) def __repr__(self): return f"<UserLedger `{self.id}`>"
class Investment(db.Model): """ SQLAlchemy object :: "investments" table. Fields ------ id : int The primary key and investment identifier. fund_id : str The fund identifier. line_id : str The line identifier. amount : float Transaction value. timestamp : datetime Timestamp of transaction. """ __tablename__ = "investments" id = db.Column(db.Integer, primary_key=True) amount = db.Column(db.Float, nullable=False) timestamp = db.Column(db.DateTime(timezone=True), default=func.now()) # relationships fund_id = db.Column(db.Integer, db.ForeignKey("funds.id"), nullable=False) line_id = db.Column(db.String(64), db.ForeignKey("lines.id"), nullable=False) def __repr__(self): return f"<Investment `{self.id}`>"
class Post(db.Model): __tablename__ = 'posts' id = db.Column(db.Integer, primary_key=True) body = db.Column(db.Text()) timestamp = db.Column(db.DateTime(), index=True, default=datetime.utcnow) author_id = db.Column(db.Integer, db.ForeignKey('users.id')) comments = db.relationship('Comment', backref='post', lazy='dynamic')
class Fight(db.Model): __tablename__ = 'fight' id = db.Column(db.Integer, primary_key=True) date = db.Column(db.String(128), index=True, unique=False) red_fighter_id = db.Column(db.Integer, index=True, unique=False) blue_fighter_id = db.Column(db.Integer, index=True, unique=False) finish_round = db.Column(db.Integer, index=True, unique=False) finish_time = db.Column(db.String(128), index=True, unique=False) allowed_round = db.Column(db.Integer, index=True, unique=False) time_created = db.Column(db.DateTime(timezone=True), server_default=func.now(), onupdate=func.current_timestamp()) def __init__(self, date, red_fighter_id, blue_fighter_id, finish_round, finish_time, allowed_round): self.date = date self.red_fighter_id = red_fighter_id self.blue_fighter_id = blue_fighter_id self.finish_round = finish_round self.finish_time = finish_time self.allowed_round = allowed_round def __repr__(self): line = ('<Fight(date=%r, red_fighter_id=%r, blue_fighter_id=%r,' 'finish_round=%r, finish_time=%r, allowed_round=%r)>') return line % (self.date, self.red_fighter_id, self.blue_fighter_id, self.finish_round, self.finish_time, self.allowed_round)