class WorkCondition(db.Model): __tablename__ = 'WorkCondition' wcond_id = db.Column(db.Integer, primary_key=True, nullable=False, autoincrement=True) cont_id = db.Column(db.ForeignKey('WorkContract.cont_id', ondelete='RESTRICT', onupdate='RESTRICT'), primary_key=True, nullable=False, index=True) user_id = db.Column(db.Integer, nullable=False, index=True) wp_id = db.Column(db.Integer, nullable=False) target_ym = db.Column(db.String(6)) target_date = db.Column(db.String(2)) week_num = db.Column(db.Integer) day_num = db.Column(db.Integer) start_time = db.Column(db.Time) end_time = db.Column(db.Time) awork_time = db.Column(db.Time) arest_time = db.Column(db.Time) hourly_pay = db.Column(db.Integer) daily_pay = db.Column(db.Integer) tardy_code = db.Column(db.Integer, nullable=False, server_default='1') wcond_status = db.Column(db.Integer, nullable=False, server_default='1') created_time = db.Column(db.DateTime, server_default=func.now()) updated_time = db.Column(db.DateTime) cont = db.relationship( 'WorkContract', primaryjoin='WorkCondition.cont_id == WorkContract.cont_id', backref='work_conditions')
class Daily(db.Model): __tablename__ = 'Daily' daily_id = db.Column(db.String(50), primary_key=True, nullable=False) wcond_id = db.Column(db.Integer, nullable=False) cont_id = db.Column(db.String(45), nullable=False) target_ym = db.Column(db.String(6), primary_key=True, nullable=False) target_date = db.Column(db.String(2), primary_key=True, nullable=False) week_num = db.Column(db.Integer) day_num = db.Column(db.Integer) work_start = db.Column(db.DateTime) work_end = db.Column(db.DateTime) act_work_time = db.Column(db.Time) cont_work_time = db.Column(db.Time) act_rest_time = db.Column(db.Time) cont_rest_time = db.Column(db.Time) over_time = db.Column(db.Time) night_time = db.Column(db.Time) holy_time = db.Column(db.Time) tardy_time = db.Column(db.Time) act_work_pay = db.Column(db.Integer) cont_work_pay = db.Column(db.Integer) over_pay = db.Column(db.Integer) night_pay = db.Column(db.Integer) holy_pay = db.Column(db.Integer) tardy_pay = db.Column(db.Integer) total_pay = db.Column(db.Integer) created_time = db.Column(db.DateTime, server_default=func.now()) updated_time = db.Column(db.DateTime)
class ScrapeTask(db.Model): __tablename__ = "scrape_tasks" id = db.Column(db.String(36), primary_key=True) name = db.Column(db.String(128), index=True) description = db.Column(db.String(128)) candidate_id = db.Column(db.Integer, db.ForeignKey('candidates.id')) inserted_on = db.Column(db.DateTime, nullable=False, default=datetime.datetime.now) updated_on = db.Column(db.DateTime, nullable=True) complete = db.Column(db.Boolean, default=False) @property def progress(self): return self.get_progress() def get_rq_job(self): try: rq_job = rq.job.Job.fetch(self.id, connection=current_app.redis) except (redis.exceptions.RedisError, rq.exceptions.NoSuchJobError): return None return rq_job def get_progress(self): job = self.get_rq_job() return job.meta.get('progress', 0) if job is not None else 100
class Newsletter(db.Model): """ Description of Newsletter Model Rows ------------------------ :id: int [pk] :description text :publish_date: varchar :newsletter_content: text :upload_time datetime :cover_image_url: varchar """ id = db.Column(db.Integer, primary_key=True, nullable=False) description = db.Column(db.Text) publish_date = db.Column(db.String(255)) newsletter_content = db.Column(db.Text) upload_time = db.Column(db.DateTime) cover_image_url = db.Column(db.String(255)) def __init__(self, description, publish_date, newsletter_content, cover_image_url): try: self.description = description self.publish_date = publish_date self.newsletter_content = newsletter_content self.upload_time = convertDateString(publish_date) self.cover_image_url = cover_image_url db.session.add(self) db.session.commit() LOG.info("New Newsletter Created - {}".format(publish_date)) except BaseException: LOG.error("Cannot create Newsletter", exc_info=True) raise BaseException
class UserModel(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) 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 count_user(cls): return cls.query.count() @classmethod def delete_all(cls): try: num_rows_deleted = db.session.query(cls).delete() db.session.commit() return {'message': '{} row(s) deleted'.format(num_rows_deleted)} except: 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 StepTransport(Step): __tablename__ = 'step_transport' id = db.Column(db.Integer, db.ForeignKey('step.id'), primary_key=True) end_address_id = db.Column(db.Integer, db.ForeignKey('place.id')) reservation_number = db.Column(db.String(30)) transport_number = db.Column(db.String(30)) end_address = db.relationship("Place") __mapper_args__ = { 'polymorphic_identity': StepType.Transport.name, } @staticmethod def from_json(dto, trip_id): return StepTransport( name=dto.get('name'), trip_id=trip_id, start_datetime=dto.get('start_datetime'), end_datetime=dto.get('end_datetime'), start_address=Place.from_json(dto.get('start_address')), end_address=Place.from_json(dto.get('end_address')), phone_number=dto.get('phone_number'), notes=dto.get('notes'), reservation_number=dto.get('reservation_number'), transport_number=dto.get('transport_number') )
class TDataType(db.Model): """ 数据源对象 """ __tablename__ = 't_datatype' id = db.Column(db.Integer, primary_key=True) cover = db.Column(db.String(150)) name = db.Column(db.String(150), unique=True) is_disabled = db.Column(db.Integer) create_time = db.Column(db.DateTime) update_time = db.Column(db.DateTime) def json_data(self): """ 将对象转换为字典数据 :return:s """ return { 'id': self.id, 'cover': self.cover, 'name': self.name, 'is_disabled': self.is_disabled, 'create_time': self.create_time, 'update_time': self.update_time } def __repr__(self): return '<tDataType %r>' % self.name
class UserModel(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String(50), unique=True) mobileNum = db.Column(db.Integer) password = db.Column(db.String(50)) role = db.Column(db.String(50))
class Debate(db.Model): """Pretty much a catch-all table for anything related to a debate at this point.""" __tablename__ = "debates" id = db.Column(db.Integer, primary_key=True) views = db.Column(db.Integer) dtype = db.Column(db.String(40)) topic = db.Column(db.String(100)) current_round_number = db.Column(db.Integer) stage = db.Column(db.String(10)) max_round_number = db.Column(db.Integer) max_claim_number = db.Column(db.Integer) isTimed = db.Column(db.String(10)) time_for_next_phase = db.Column(db.DateTime) pro_votes = db.Column(db.Integer) con_votes = db.Column(db.Integer) definitions = db.relationship("Definition", backref="Debate") claims = db.relationship("Claim", backref="Debate") users = db.relationship("UserDebate", back_populates="debate", cascade="all, delete-orphan") users_voted = db.relationship("User", secondary=user_vote_tally, back_populates="debates_voted") has_sent_finished_emails = db.Column(db.Boolean, default=False)
class User(db.Model): """ User Model for storing user related details """ __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) public_id = db.Column(db.String(100), unique=True) username = db.Column(db.String(50), unique=True) password_hash = db.Column(db.String(100)) @property def password(self): raise AttributeError('password: write-only field') @password.setter def password(self, password): self.password_hash = flask_bcrypt.generate_password_hash(password).decode('utf-8') def check_password(self, password): return flask_bcrypt.check_password_hash(self.password_hash, password) def __repr__(self): return "<User '{}'>".format(self.username)
class Post(db.Model): __tablename__ = "post" id = db.Column(db.Integer, primary_key=True, autoincrement=True) title = db.Column(db.String(200)) content = db.Column(db.String(1000)) user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
class ImageModel(db.Model): """ Model for storing image related details """ __tablename__ = 'images' id = db.Column(db.Integer, primary_key=True) sha256 = db.Column(db.String(64, convert_unicode=True), nullable=False, index=True) phash = db.Column(db.BigInteger, nullable=False, index=True) url = db.Column(db.String(255, convert_unicode=True), nullable=False, index=True) context = db.Column(JSONB(), default=[], nullable=False) __table_args__ = ( db.Index('ix_images_context', context, postgresql_using='gin'), ) @staticmethod def from_url(url, context={}): """Fetch an image from a URL and load it :param url: Image URL :returns: ImageModel object """ remote_request = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'}) remote_response = urllib.request.urlopen(remote_request) raw = remote_response.read() im = Image.open(io.BytesIO(raw)).convert('RGB') phash = compute_phash_int(im) sha256 = sha256_stream(io.BytesIO(raw)) return ImageModel(sha256=sha256, phash=phash, url=url, context=context)
class Users(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) user_id = db.Column(db.String(255), nullable=False) password_hash = db.Column(db.String(100)) register_on = db.Column(db.DateTime, nullable=False) last_pass_change = db.Column(db.DateTime, nullable=False) name = db.Column(db.String(255), nullable=False) surname = db.Column(db.String(255), nullable=False) email = db.Column(db.String(255), unique=True, nullable=False) country_city_id = db.Column(db.Integer, db.ForeignKey('countries_cities.id'), nullable=False) # TODO: Fix the logic about how to do this. Many to many new table is need, isn't? # technologies = db.relationship('Technologies', backref=db.backref('techs', # lazy=True)) @property def password(self): raise AttributeError("password: write-only field") @password.setter def password(self, password): self.password_hash = flask_bcrypt.generate_password_hash(password).decode('utf-8') def check_password(self, password): return flask_bcrypt.check_password_hash(self.password_hash, password) def __repr__ (self): return f"<Person '{self.name} {self.surname} - {self.email}"
class Menu(db.Model): __tablename__ = 'sys_menu' id = db.Column(db.Integer, primary_key=True, autoincrement=True) parent_id = db.Column(db.Integer, comment=u'父菜单') name = db.Column(db.String(50), comment=u'菜单名称') icon = db.Column(db.String(50), comment=u'菜单图标') url = db.Column(db.String(250), comment=u'菜单路径') order = db.Column(db.SmallInteger, default=0, comment=u'排序') type = db.Column(db.Integer, comment=u'类型 0:目录 1:菜单 2:按钮') status = db.Column(db.Integer, default=1, comment=u'状态') createTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'创建时间') createBy = db.Column(db.String(50), comment=u'创建人') updateTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'修改时间') updateBy = db.Column(db.String(50), comment=u'修改人') def save(self): globals.db.add(self) globals.db.commit() def update(self): globals.db.commit() def delete(self): globals.db.delete(self) globals.db.commit() def __repr__(self): return '<Menu %r>' % self.name
class UserMetaData(db.Model): __tablename = "user_metadata" id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey("user.id")) value = db.Column(db.String(64), index=True) key = db.Column(db.String(64), index=True) user = db.relationship("User", back_populates="user_metadata")
class Category(db.Model): #creating category table in database __tablename__= "category" category_id =db.Column(db.Integer, primary_key=True) user_id = db.Column(db.String(50), nullable=False) category = db.Column(db.String(50), nullable=False) parent_id = db.Column(db.Integer)
class SupermarketModel(BaseModel): __tablename__ = 'supermarkets' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(100), nullable=False, unique=True) address = db.Column(db.String(100), nullable=False) _open_time = db.Column("open_time", db.Integer(), nullable=False) _close_time = db.Column("close_time", db.Integer(), nullable=False) @property def open_time(self): """Return open_time value""" return seconds_to_time(self._open_time) @open_time.setter def open_time(self, value): """Set open_time value """ self._open_time = time_to_seconds(value) @property def close_time(self): """Return close_time value""" return seconds_to_time(self._close_time) @close_time.setter def close_time(self, value): """Set close_time value""" self._close_time = time_to_seconds(value)
class SecurityUser(db.Model): """ storing login/password pairs to provide direct login mechanism""" __tablename__ = "security_users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(50), unique=True) password_hash = db.Column(db.String(100)) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False, unique=True) user = relationship(User.__name__) @property def password(self): raise AttributeError('password: write-only field') @password.setter def password(self, password): self.password_hash = flask_bcrypt.generate_password_hash( password).decode('utf-8') def check_password(self, password): return flask_bcrypt.check_password_hash(self.password_hash, password) def __repr__(self): return f"<Security User {self.username}>"
class User(db.Model): __tablename__ = 'users' id = db.Column(db.BigInteger, primary_key=True) username = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.UnicodeText, nullable=False) first_name = db.Column(db.UnicodeText, nullable=False) last_name = db.Column(db.UnicodeText, nullable=False) title = db.Column(db.UnicodeText, nullable=False) email = db.Column(db.String(255), unique=True, nullable=False) enabled = db.Column(db.Boolean(), nullable=False, default=True, server_default='1') @property def full_name(self): return ' '.join([self.first_name, self.last_name]) # Required for flask-login @property def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return str(self.id)
class Company(db.Model): __tablename__ = "COMPANY" id = db.Column(db.String(32), primary_key=True) name = db.Column(db.String(256), index=True, unique=True) link = db.Column(db.String(256), index=True, unique=True) contents = db.relationship("Content", secondary=association_table, back_populates="companies")
class User(db.Model): __tablename__ = "user" id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(), unique=True) public_id = db.Column(db.String(100), unique=True) def __repr__(self): return "User: {}".format(self.username)
class Order(db.Model): # creating order table in the database __tablename__ = "orders" id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey("users.id")) payment_status = db.Column(db.String(50)) status = db.Column(db.String(50)) amount = db.Column(db.Integer)
class ClientModel(BaseModel): __tablename__ = 'clients' id = db.Column(db.Integer, primary_key=True, autoincrement=True) dni = db.Column(db.Numeric(8,0), nullable=False) first_name = db.Column(db.String(100)) last_name = db.Column(db.String(100)) phone = db.Column(db.Integer)
class User(db.Model, UserMixin): """ sqlalchemy.exc.InvalidRequestError: Table 'xxx' is already defined for this MetaData instance. Specify 'extend_existing=True' to redefine options and columns on an existing Table object. """ __table_args__ = dict(mysql_charset='utf8', extend_existing=True) id = db.Column(db.Integer, primary_key=True, autoincrement=True) username = db.Column(db.String(100), unique=True, nullable=False) password_hashed = db.Column(db.String(200), nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) def __init__(self, user_data): self.username = user_data.get('username') self.password = user_data.get('password') self.email = user_data.get('email') @property def password(self): raise AttributeError('password: write-only field') @password.setter def password(self, password): self.password_hashed = bcrypt.generate_password_hash(password).decode( 'utf-8') def check_password(self, password): return bcrypt.check_password_hash(self.password_hashed, password) def save(self): db.session.add(self) db.session.commit() @classmethod def check_login(cls, user_data): user = User.query.filter_by(username=user_data.get('username')).first() if user is not None: if user.check_password(user_data.get('password')): return user else: return False @classmethod def find_byID(cls, user_id): return User.query.get(user_id) @classmethod def get_all(cls): users = [user.__repr__() for user in User.query.all()] return '[{}]'.format(', '.join(users)) def __repr__(self): return json.dumps( dict( id=self.id, username=self.username, password_hashed=self.password_hashed, email=self.email, ))
class Users(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) email = db.Column(db.String(255), unique=True, nullable=False) password_hash = db.Column(db.String(100)) photo_url = db.Column(db.String(255)) # created = db.Column( # db.DateTime, nullable=False, default=datetime.datetime.now() # ) # created_by = db.Column(db.Integer, nullable=False) # last_modified = db.Column( # db.DateTime, # nullable=False, # default=datetime.datetime.now(), # onupdate=datetime.datetime.now() # ) # last_modified_by = db.Column(db.Integer) active = db.Column(db.Boolean, default=True, nullable=False) def __repr__(self): return "<Users: {}".format(self.id) def add_record(data): return Users( name=data.get("name", ''), email=data.get("email"), password_hash=password(data.get("password")), photo_url=data.get("photo_url", ''), # created_by = user_id, # last_modified_by = user_id ) def update_record(row, data): row.name = data.get("name", row.name) row.email = data.get("email", row.email) if data.get("password", False): row.password_hash = password(data.get("password")) row.photo_url = data.get("photo_url", row.photo_url) row.active = data.get("active", row.active) # row.last_modified_by = user_id def generate_token(user, password): is_matched = check_password(user.password_hash, password) if not is_matched: return {"status": "Invalid Credentials!"}, 401 payload = { 'exp': datetime.datetime.now() + datetime.timedelta(days=30), 'iat': datetime.datetime.now(), 'sub': user.id } # row = AccessToken.add_row(user.id) # db.session.add(row) # db.session.commit() return { "token": str(jwt.encode(payload, key, algorithm="HS256")), "status": "Login successfully" }, 200
class Role(db.Model): __tablename__ = 'sys_role' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(64), unique=True, comment=u'角色名称') describe = db.Column(db.String(200), unique=True, comment=u'角色描述') status = db.Column(db.Integer, default=1, comment=u'状态') createTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'创建时间') createBy = db.Column(db.String(50), comment=u'创建人') updateTime = db.Column(db.DATETIME, server_default=func.now(), comment=u'修改时间') updateBy = db.Column(db.String(50), comment=u'修改人') # @property # def permissions(self): # permissions = Permission.query.join(sys_role_permission).join(Role).filter(Role.id == self.id) # return permissions menus = db.relationship('Menu', secondary=sys_role_menu, backref=db.backref('menus', lazy='dynamic')) # @property # def menus(self): # menus = Menu.query.join(sys_role_menu).join(Role).filter(Role.id == self.id).order_by(Menu.type, Menu.order).all() # return menus @property def permission_names(self): strs = '' for i in range(len(self.menus)): strs = strs + self.menus[i].name + ',' return strs @property def create_time(self): return self.createTime.strftime('%Y-%m-%d') @property def menu_ids(self): ids = [] for i in range(len(self.menus)): if self.menus[i].url is not None: ids.append(self.menus[i].id) return ids def __init__(self): pass def save(self): globals.db.add(self) globals.db.commit() def update(self): globals.db.commit() def delete(self): globals.db.delete(self) globals.db.commit() def __repr__(self): return '<Role %r>' % self.name
class User(db.Model): #creating user table in database __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(50)) fullname = db.Column(db.String(50)) Password = db.Column(db.String(50)) Type = db.Column(db.String(50)) Contact = db.Column(db.Integer)
class Issue(db.Model): """ Description of Issue Model Rows ------------------------ :id: int [pk] :date_created: datetime :month: Month :year: int :issue_tag: varchar [ref: > tags.name] :cover: int [ref: > imgLinks.id] :link: varchar """ id = db.Column(db.Integer, primary_key=True, nullable=False) created_at = db.Column(db.DateTime) month = db.Column(db.Enum(Month)) year = db.Column(db.Integer) issue_tag = db.Column(db.String(20), db.ForeignKey('tag.name')) cover = db.Column(db.Integer, db.ForeignKey('imgLink.id')) link = db.Column(db.String(256)) description = db.Column(db.Text, nullable=True) tag = db.relationship('Tag', lazy=False) cover_img = db.relationship('ImgLink', lazy=False) def __init__(self, coverId, month, year, link): try: tagName = str(month) + str(year[-2:]) self.created_at = datetime.datetime.now() self.month = Month[month] self.year = year self.link = link self.cover = coverId self.setIssueTag(tagName) db.session.add(self) db.session.commit() LOG.info("New Issue Created") except BaseException: LOG.error("Cannot create Issue", exc_info=True) def setIssueTag(self, tagName): existing_tags = Tag.query.filter_by(name=tagName).all() if len(existing_tags) == 0: existing_tag = Tag(tagName) self.tag = existing_tag db.session.commit() else: self.tag = existing_tags[0] db.session.commit() LOG.info(f"Issue tag set for { tagName }") def setDescription(self, desc): self.description = desc db.session.commit()
class Wallet(db.Model): __tablename__ = 'wallets' id = db.Column(db.Integer, primary_key=True) public_id = db.Column(db.String(60), unique=True, nullable=False, index=True) user_id = db.Column(db.String(60), db.ForeignKey('users.public_id')) balance = db.Column(db.Float, nullable=False, default=0.0) created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow, nullable=False) updated_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
class HostVariable(db.Model): """ HostVariable Model for storing inventory hosts variables """ __tablename__ = "host_variable" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), unique=False, nullable=False) value = db.Column(db.String(1024), unique=False, nullable=False) host_id = db.Column(db.Integer, db.ForeignKey('host.id')) host = relationship("Host", back_populates="vars")