class UserModel(db.Model,UserMixin): '''user model : representing user information in sql table''' __tablename__='users' id=db.Column(db.Integer,primary_key=True) email=db.Column(db.String(50),unique=True,nullable=False) password=db.Column(db.String(256),nullable=False) mobile_no=db.Column(db.String(10),nullable=False) billing_address=db.Column(db.Text,nullable=True) delivery_address=db.Column(db.Text,nullable=True) products=db.relationship('ProductModel',backref='user',lazy=True,cascade='all,delete') def __init__(self,email,password,mobile_no): self.email=email self.password=bcrypt.generate_password_hash(password).decode('utf-8') self.mobile_no=mobile_no def update_password(self,password): '''update password''' self.password=bcrypt.generate_password_hash(password).decode('utf-8') def __repr__(self): return f"hello i am {self.email}" def check_password(self,password): '''check users password''' return bcrypt.check_password_hash(self.password,password)
class ProductModel(BaseModel): # table name __tablename__ = 'products' id = db.Column(db.Integer, primary_key=True) shop_id = db.Column(db.Integer, db.ForeignKey('shops.id', ondelete='CASCADE'), nullable=False) name = db.Column(db.String(128), nullable=False) description = db.Column(db.String(128), nullable=False) price = db.Column(db.Float, nullable=False) # class constructor def __init__(self, data): """ Class constructor """ self.shop_id = data.get('shop_id') self.name = data.get('name') self.description = data.get('description') self.price = data.get('price') @staticmethod def get_product(product_id): response = ProductModel.query.get(product_id) if not response: raise NotFoundException("Invalid ID") return response
class Film(db.Model): __tablename__ = 'films' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(128), nullable=False) release_date = db.Column(db.Date, index=True, nullable=False) uuid = db.Column(db.String(36), unique=True) description = db.Column(db.Text) distributed_by = db.Column(db.String(120), nullable=False) length = db.Column(db.Float) rating = db.Column(db.Float) def __routes__(self, title, release_date, description, distributed_by, length, rating): self.title = title self.release_date = release_date self.description = description self.distributed_by = distributed_by self.length = length self.rating = rating self.uuid = str(uuid.uuid4()) def __repr__(self): return f'Film({self.title}, {self.uuid}, {self.distributed_by}, {self.release_date})' def to_dict(self): return { 'title': self.title, 'uuid': self.uuid, 'release_date': self.release_date.strftime('%Y-%m-%d'), 'description': self.description, 'distributed_by': self.distributed_by, 'length': self.length, 'rating': self.rating }
class User(db.Model): user_id = db.Column(db.BIGINT(), primary_key=True) user_name = db.Column(db.String(255), unique=False, nullable=False) login = db.Column(db.String(255), unique=True, nullable=True) def __repr__(self): return '<User %r>' % self.login
class NormalUserModel(UserModel): # table name __tablename__ = 'normal_users' user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'), primary_key=True) suscripcion = db.Column(db.String(128), nullable=False) picture = db.Column(db.String(256), nullable=True) make_favours = db.Column(db.Boolean, nullable=False) __mapper_args__ = { 'polymorphic_identity': 'normal_users', } # class constructor def __init__(self, data): """ Class constructor """ super(NormalUserModel, self).__init__(data) self.suscripcion = data.get('suscripcion') self.picture = data.get('picture') self.make_favours = data.get('make_favours', True) @staticmethod def get_user(user_id): response = NormalUserModel.query.get(user_id) if not response: raise NotFoundException("Invalid ID") return response
class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) def __repr__(self): return '<User %r>' % self.username
class Posts(db.Model): id = db.Column(db.Integer, primary_key=True) deleted = db.Column(db.Boolean, default=False) deleted_at = db.Column(db.DateTime, default=None) created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow) updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) title = db.Column(db.String(200), nullable=False) thumbnail = db.Column(db.Text) slug = db.Column(db.String(200), nullable=False, unique=True) brief = db.Column(db.Text, nullable=False) content = db.Column(db.Text, nullable=False) last_edited_at = db.Column(db.DateTime) user = db.relationship('Users', backref=db.backref('posts', lazy=True)) votes = db.relationship("Votes", back_populates="post") tags = db.relationship('Tags', secondary=post_tags, lazy='subquery', backref=db.backref('posts', lazy=True)) def __repr__(self): return '<Posts %r>' % self.title
class Creator(db.Model): __tablename__ = 'creator' id = db.Column(db.Integer(), primary_key=True) firstName = db.Column(db.String(100)) middleName = db.Column(db.String(100)) lastName = db.Column(db.String(100)) suffix = db.Column(db.String(100)) fullName = db.Column(db.String(100)) modified = db.Column(db.DateTime()) comics = db.relationship(Comics, secondary=creator_comics, backref=db.backref('creators', lazy=True)) def __init__(self, id, firstName, middleName, lastName, suffix, fullName, modified, comics): self.id = id self.firstName = firstName self.middleName = middleName self.lastName = lastName self.suffix = suffix self.fullName = fullName self.modified = modified self.comics = comics def create(self): db.session.add(self) db.session.commit() return self
class Name(db.Model): __tablename__ = 'name' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(400)) disposition = db.Column(db.String(400)) hat_id = db.Column(db.Integer, db.ForeignKey('hat.id'))
class Project(db.Model): __tablename__ = 'Projects' __table_args__ = {'extend_existing': True} name = db.Column(db.String(50), primary_key=True, index=True) descriptions = db.Column(db.String(75), index=True) def __repr__(self): return f"<Project: name: {self.full_name}, descriptions: {self.descriptions}>"
class Goal(db.Model): __tablename__ = 'goals' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) description = db.Column(db.String(255)) icon = db.Column(db.String(255)) teachers = db.relationship('Teacher', secondary=teacher_goals, back_populates='goals')
class Reports(db.Model): __tablename__ = 'reports' id = db.Column(db.Integer, primary_key=True) content = db.Column(db.Text) xml_path = db.Column(db.String(200)) pdf_path = db.Column(db.String(200)) active = db.Column(db.Integer, default=0) processing = db.Column(db.Integer, default=0) created = db.Column(db.DateTime, default=datetime.utcnow) updated = db.Column(db.DateTime)
class Brand(db.Model): brand_id = db.Column(db.BIGINT(), primary_key=True, nullable=False) brand_name = db.Column(db.String(511), nullable=False) email = db.Column(db.String(255)) phone = db.Column(db.String(15)) address = db.Column(db.String(511)) archived = db.Column(db.Boolean(), nullable=False, default=False) def __repr__(self): return '<Brand %r>' % self.brand_name
class PackingType(db.Model): packing_type_id = db.Column(db.BIGINT(), primary_key=True, nullable=False) packing_label_url = db.Column(db.String(1023)) code_iso = db.Column(db.String(15)) code_gost = db.Column(db.String(15)) packing_description = db.Column(db.String(511)) packing_examples = db.Column(db.String(511)) archived = db.Column(db.Boolean(), nullable=False, default=False) def __repr__(self): return '<Packing_Type %r>' % self.brand_name
class CarModel(db.Model): __tablename__ = 'cars' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(120), nullable=False) make = db.Column(db.String(120), nullable=False) model = db.Column(db.String(120), nullable=False) time_created = db.Column(db.DateTime(), default=datetime.datetime.utcnow) time_updated = db.Column(db.DateTime(), onupdate=datetime.datetime.utcnow) owner_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) owner = db.relationship('UserModel', back_populates='cars') def persist(self): db.session.add(self) db.session.commit() @staticmethod def get_marshaller(): return { 'id': fields.Integer, 'name': fields.String, 'make': fields.String, 'model': fields.String, 'time_created': fields.DateTime, 'time_updated': fields.DateTime, 'owner': fields.Nested(UserModel.get_marshaller()) } @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).first() @classmethod def return_all(cls): return CarModel.query.all() @classmethod def return_all_for_user(cls, user_id): return CarModel.query.filter(cls.owner_id == user_id).all() @classmethod def delete_all(cls): db.session.query(cls).delete() db.session.commit() @classmethod def delete_by_id(cls, id): car = db.session.query(cls).filter(cls.id == id).first() if car: db.session.delete(car) db.session.commit() else: raise NoData
class Professor(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(30), unique=False, nullable=False) surname = db.Column(db.String(30), unique=False, nullable=False) # Rank of the teacher eg. PhD... merits = db.Column(db.String(20), unique=False, nullable=False) # Relationship for foreign key in a different table study_classes = db.relationship('StudyClass', backref='professor') discipline = db.relationship('Discipline', backref='professor') def __repr__(self): return f'{self.merits} {self.name} {self.surname}'
class Teacher(db.Model): __tablename__ = 'teachers' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) about = db.Column(db.Text) rating = db.Column(db.Float) picture = db.Column(db.String(255)) price = db.Column(db.Integer) goals = db.relationship('Goal', secondary=teacher_goals, back_populates='teachers') free = db.Column(JSON)
class Records(db.Model): __tablename__ = 'records' __table_args__ = {'extend_existing': True} uuid = db.Column(UUID(as_uuid=True), primary_key=True) country_iso = db.Column(db.String(100), index=True) country_name = db.Column(db.String(100)) date = db.Column(DATE) confirmed = db.Column(db.INTEGER) deaths = db.Column(db.INTEGER) recovered = db.Column(db.INTEGER) def __repr__(self): return f'<Record ID: {self.uuid}, ISO: {self.country_iso}, Country: {self.country_name}, Date: {self.date}, {self.confirmed, self.deaths, self.deaths}>'
class Books(db.Model): __tablename__ = "books" id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(150)) author = db.Column(db.String(100)) created_on = db.Column(db.DateTime, server_default=db.func.now()) updated_on = db.Column(db.DateTime, server_default=db.func.now(), server_onupdate=db.func.now()) def __repr__(self): return "<Books id={}, title={}, author={}>".format( self.id, self.title, self.author)
class StudyClass(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(10), unique=True, nullable=False) year_of_study = db.Column(db.String(2), unique=False, nullable=False) schedule_id = db.Column(db.Integer, db.ForeignKey('schedule.id')) professor_id = db.Column(db.Integer, db.ForeignKey('professor.id')) schedule = db.relationship('Schedule', backref=db.backref('classes', lazy=True)) discipline = db.relationship('Discipline', backref='study_class') def __repr__(self): return f'{self.name} {self.year_of_study}'
class Tags(db.Model): id = db.Column(db.Integer, primary_key=True) deleted = db.Column(db.Boolean, default=False) deleted_at = db.Column(db.DateTime, default=None) created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow) updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) name = db.Column(db.String(80), nullable=False, unique=True) slug = db.Column(db.String(200), nullable=False, unique=True) def __repr__(self): return '<Tags %r>' % self.name
class Discipline(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), unique=False, nullable=False) # Day of the week + hour interval of the class course_schedule = db.Column(db.String(50), unique=False, nullable=True) lab_schedule = db.Column(db.String(50), unique=False, nullable=True) seminary_schedule = db.Column(db.String(50), unique=False, nullable=True) schedule_id = db.Column(db.Integer, db.ForeignKey('schedule.id')) study_class_id = db.Column(db.Integer, db.ForeignKey('study_class.id')) professor_id = db.Column(db.Integer, db.ForeignKey('professor.id')) def __repr__(self): return f'{self.name} {self.course_schedule} {self.lab_schedule} {self.seminary_schedule}'
class User(UserMixin, Base): __tablename__ = 'auth_user' first_name = db.Column(db.String(128), nullable=False) last_name = db.Column(db.String(128), nullable=False) # Identification data email = db.Column(db.String(128), nullable=False, unique=True) password_hash = db.Column(db.String(192), nullable=False) # Authorization data # role = db.Column(db.SmallInteger, nullable=False) # status = db.Column(db.SmallInteger, nullable=False) # Initialization procedure for new instances # def __init__(self, first_name, last_name, email, password): # self.first_name = first_name # self.last_name = last_name # self.email = email # self.password_hash = password_hash def set_password(self, password): self.password_hash = generate_password_hash(password) def verify_password(self, password): return check_password_hash(self.password_hash, password) def generate_auth_token(self, expiration=600): s = Serializer(current_app.config['SECRET_KEY'], expires_in=expiration) return s.dumps({'id': self.id}) @staticmethod def verify_auth_token(token): s = Serializer(current_app.config['SECRET_KEY']) try: data = s.loads(token) user = User.query.get(data['id']) return user except SignatureExpired: return None except BadSignature: return None def __repr__(self): return f'<User {self.first_name} {self.email}>'
class Employee(db.Model): id = db.Column(db.Integer, primary_key=True) department_id = db.Column(db.Integer, db.ForeignKey("department.id")) name = db.Column(db.String(250)) surname = db.Column(db.String(250)) slug = db.Column(db.String(250)) salary = db.Column(db.Integer) birth_date = db.Column(db.Date) def __init__(self, *args, **kwargs): super(Employee, self).__init__(*args, **kwargs) self.slug = slugify(self.name + self.surname) def __repr__(self): return f"<Employee : name: {self.name}, surname: {self.surname}, department: {self.department_id}>"
class User(UserMixin, db.Model): """Model for user accounts.""" # __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), index=False, unique=False, nullable=False) password = db.Column(db.String(200), primary_key=False, unique=False, nullable=False) email = db.Column(db.String(80), index=True, unique=False, nullable=False) admin = db.Column(db.Boolean, index=False, unique=False, nullable=False)
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) name = db.Column(db.String(120), nullable=False) surname = db.Column(db.String(120), nullable=False) email = db.Column(EmailType, unique=True, nullable=False) def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def find_by_email(cls, email): return cls.query.filter_by(email=email).first() @classmethod def return_all(cls): def to_json(x): return { 'username': x.username, 'password': x.password } return {'users': list(map(to_json, User.query.all()))} @classmethod def delete_all(cls): try: num_rows_deleted = db.session.query(cls).delete() db.session.commit() return {'message': f'{num_rows_deleted} row(s) deleted'} except Exception as e: return {'message': 'Something went wrong'} @staticmethod def generate_hash(password): return sha256.hash(password) @staticmethod def verify_hash(password, hash): return sha256.verify(password, hash)
class Character(db.Model): __tablename__ = 'character' id = db.Column(db.Integer, primary_key=True) available = db.Column(db.Integer) collectionURI = db.Column(db.String(140)) returned = db.Column(db.Integer) comic_id = db.Column(db.Integer, db.ForeignKey('comics.id'))
class Department(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255)) slug = db.Column(db.String(255)) employees = db.relationship("Employee") def __init__(self, *args, **kwargs): super(Department, self).__init__(*args, **kwargs) self.generate_slug() def generate_slug(self): if self.name: self.slug = slugify(self.name) def __repr__(self): return f"<Department : name={self.name}, id={self.id}>"
class ActivityLog(db.Model): """ Describes an activity by (optional) user (and/or) on some (optional) post, or just a message about what was done """ id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=True) post_id = db.Column(db.Integer, db.ForeignKey("post.id"), nullable=True) action = db.Column(db.String(255)) date = db.Column(db.Date, default=datetime.date.today()) time = db.Column(db.Time, default=datetime.datetime.now().time()) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) def __repr__(self): return f"<Activity: id={self.id}, user={self.user_id}, post={self.post_id}, " \ f"action={self.action}, date={self.date}, time={self.time}>" def json(self): return { "user_id": self.user_id, "post_id": self.post_id, "action": self.action, "date": str(self.date), "time": str(self.time) }
class Build(db.Model): _id = db.Column(db.Integer, primary_key=True) # ID in database (is unique) id = db.Column( db.Integer) # ID in job, together with job_id is an unique tuple description = db.Column(db.Text) commands = db.Column(db.Text) output = db.Column(db.Text) status = db.Column(db.String(32)) job_id = db.Column(db.Integer, db.ForeignKey("job.id")) node_id = db.Column(db.Integer, db.ForeignKey("node.id")) created_date = db.Column(db.DateTime, default=datetime.datetime.utcnow) def to_dict(self): return { 'id': self.id, 'description': self.description, 'commands': self.commands, 'output': self.output, 'status': self.status, 'job_id': self.job_id, 'node_id': self.node_id, 'created_date': self.created_date.strftime("%m/%d/%Y, %H:%M:%S") } def __repr__(self): return f"<id {self.id}, description : {self.description}>"