class CrawlResponse(Base): __tablename__ = "crawl_responses" crawl_uuid = Column(PGUUID, ForeignKey("crawl_requests.crawl_uuid"), primary_key=True) body_uuid = Column(PGUUID, unique=True, nullable=False) headers = Column(JSONB(), nullable=False, index=False) status_code = Column(satypes.SmallInteger, nullable=False, index=True) request_obj: "RelationshipProperty[CrawlRequest]" = relationship( CrawlRequest, uselist=False, backref=backref("response_obj", uselist=False), )
class ContactRoomSession(CommonModel): __tablename__ = 'contact_room_session' start_time = db.Column(BigInteger) end_time = db.Column(BigInteger) do_not_distrub = db.Column(Boolean(), default=False) extra_data = db.Column(JSONB()) people_number = db.Column(Integer()) children_number = db.Column(Integer(), default = 0) note = db.Column(Text()) checkout = db.Column(Boolean(), default=False) contacts = db.relationship("Contact") rooms = db.relationship("Room") contact_id = db.Column(UUID(as_uuid=True), ForeignKey("contact.id", onupdate="CASCADE", ondelete="RESTRICT")) room_id = db.Column(UUID(as_uuid=True), ForeignKey("room.id", onupdate="CASCADE", ondelete="RESTRICT")) tenant_id = db.Column(String(), ForeignKey("tenant.id", onupdate="CASCADE", ondelete="RESTRICT"), nullable=False)
class Message(db.Model, Helper): __tablename__ = 'messages' messages_id = Column(Integer, primary_key=True, server_default=text("nextval('messages_messages_id_seq'::regclass)")) timestamp = Column(DateTime, server_default=text("timezone('utc'::text, now())")) agent_id = Column(ForeignKey('agents.agent_id', ondelete='CASCADE')) user_id = Column(String) user_name = Column(String) message_text = Column(String) message_rich = Column(JSONB(astext_type=Text())) user_message_ind = Column(Boolean) intent_id = Column(ForeignKey('intents.intent_id', ondelete='SET NULL')) agent = relationship('Agent') intent = relationship('Intent')
class Account(db.Model): __tablename__ = 'account' id = db.Column(UUID(as_uuid=True), primary_key=True, default=lambda: uuid.uuid4().hex) user = db.relationship('User', back_populates='account') account_history = db.relationship("AccountHistory", backref='account', lazy='dynamic') # Payment information payment_vendor_code = db.Column( db.String(64), nullable=True) # For example, 'stripe' or 'paypal' payment_data = db.Column( JSONB(), nullable=True) # Vendor-specific information in Json format
class Identity(db.Model): __tablename__ = "identities" id = db.Column(db.BigInteger(), primary_key=True) sub = db.Column(db.String(), nullable=False) idp = db.Column(db.String(), nullable=False) user_id = db.Column(db.ForeignKey("users.id"), nullable=False) created_at = db.Column(db.Integer(), nullable=False, default=lambda: int(time.time())) profile = db.Column(JSONB(), nullable=False, default={}) identities_idp_sub_idx = db.Index("identities_idp_sub_idx", "sub", "idp", unique=True)
class Group_Messages(UserMixin, db.Model): __tablename__ = 'group_messages' gmessage_id = db.Column(db.Integer, primary_key=True) sender_id = db.Column(db.Integer) group_id = db.Column(db.Integer) message_content = db.Column(JSONB(), nullable=False) seen = db.Column(db.Integer, default=0) edited = db.Column(db.String(4), nullable=True) timestamp = db.Column(db.DateTime, default=datetime.datetime.now()) def __init__(self, sender_id, reciever_id, content, timestamp): self.sender_id = sender_id self.message_content = content self.reciever_id = reciever_id self.timestamp = timestamp
class IsxApplication(Base): __tablename__: str = 'isx_application' application_id = Column(UUID, primary_key=True, index=True) name = Column(String(40), nullable=False) description = Column(String(256)) callback_url = Column(String(4000), nullable=False) public_key = Column(String(2048), nullable=False) private_key = Column(String(4096), nullable=False) environment = Column(String(50), nullable=False) configuration = Column(JSONB(astext_type=Text())) last_modified = Column(DateTime) is_enabled = Column(Boolean, index=True) is_soft_deleted = Column(Boolean)
class PriceList(CommonModel): __tablename__ = 'price_list' price_list_name = db.Column(String()) is_default = db.Column(Boolean(), default=False) start_time = db.Column(BigInteger) end_time = db.Column(BigInteger) extra_data = db.Column(JSONB()) items = db.relationship("Item", secondary="item_price_list") # workstation_id = db.Column(UUID(as_uuid=True), ForeignKey("workstation.id", ondelete="SET NULL")) # workstation = db.relationship("Workstation") # tenant_id = db.Column(String(), ForeignKey("tenant.id", onupdate="RESTRICT", ondelete="RESTRICT"), nullable=False)
class Posts(UserMixin, db.Model): __tablename__ = 'posts' post_id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer) post_content = db.Column(JSONB()) # post_content = db.Column(db.String(3000), nullable=False) timestamp = db.Column(db.DateTime, default=datetime.datetime.now()) privacy = db.Column(db.String(8), default='public') edited = db.Column(db.String(4), nullable=True) def __init__(self, user_id, post_content, privacy, timestamp): self.user_id = user_id self.post_content = post_content self.privacy = privacy self.timestamp = timestamp
class ProductItem(db.Model, Deleted, Versioned, Timestamped, Cached, JsonSerializableMixin): __tablename__ = 'product_items' id = db.Column(db.Integer(), primary_key=True) product_id = db.Column(db.Integer(), db.ForeignKey('products.id', ondelete='cascade'), nullable=False) name = db.Column(db.Unicode(32), nullable=True) info = db.Column(JSONB()) spec = db.Column(db.Unicode(16)) # 规格 price = db.Column(db.Numeric(precision=10, scale=2, asdecimal=False), db.CheckConstraint('price>0'), nullable=False) @property def quantity(self): return ProductItemStock.query.\ cache_option('product_item:%s:quantity' % self.id). \ with_entities(ProductItemStock.quantity).\ filter(ProductItemStock.product_item_id == self.id).scalar() @property def product(self): product_model = get_model('Product') return product_model.from_cache_by_id(self.product_id) @classmethod def price_at_submitted(cls, item_id, datetime_submitted): return ProductItemPrice.query.with_entities(ProductItemPrice.price).\ filter(ProductItemPrice.product_item_id == item_id, ProductItemPrice.created <= datetime_submitted).\ order_by(db.desc(ProductItemPrice.created)).limit(1).scalar() def __eq__(self, other): if isinstance(other, ProductItem) and other.id == self.id: return True else: return False def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return hash(self.id) def __repr__(self): return u'<ProductItem(id=%s)>' % self.id
class Gallery(UserMixin, db.Model): __tablename__ = 'gallery' gallery_id = db.Column(db.Integer, primary_key=True) upload_type = db.Column(db.String(8)) upload_used_as = db.Column(db.String(20)) upload_path = db.Column(JSONB()) privacy = db.Column(db.String(8), default='public') timestamp = db.Column(db.DateTime, default=datetime.datetime.now()) def __init__(self, upload_type, upload_path, upload_used_as, privacy, timestamp): self.gallery_type = upload_type self.upload_type = upload_type self.upload_used_as = upload_used_as self.upload_path = upload_path self.privacy = privacy self.timestamp = timestamp
class AnalyticsPageview(Base): __tablename__ = "analytics_pageview" id = Column( Integer, primary_key=True, server_default=text("nextval('analytics_pageview_id_seq'::regclass)"), ) created = Column(DateTime(True), nullable=False) updated = Column(DateTime(True), nullable=False) meta = Column(JSONB(astext_type=Text()), nullable=False) session_id = Column( ForeignKey("analytics_usersession.id", deferrable=True, initially="DEFERRED"), index=True, ) session = relationship("AnalyticsUsersession")
class NERFeature(Base): """features, using for NER: lemmas coordinates""" __tablename__ = 'ner_features' doc_id = Column(UUIDType(binary=False), ForeignKey('documents.doc_id')) # 1 - embedding, 2 - gazetteer, 3 - tomita fact, 4 - syntactic feature: case, 5 - syntactic feature: plural/singular feature_type = Column(Integer()) # fact_id, gaz_id, emb_id, ... feature = Column(String(40)) # lemma coordinates word_index = Column(Integer) sentence_index = Column(Integer) # value = Column(ARRAY(item_type=Float, dimensions=1)) value = Column(JSONB()) __table_args__ = (PrimaryKeyConstraint(doc_id, feature_type, feature, word_index, sentence_index),)
class Change(Base): """document changes made in client""" __tablename__ = 'changes' # id of document document_id = Column(UUIDType(binary=False), ForeignKey('records.document_id')) # version of document version = Column(Integer()) # change data data = Column(JSONB()) # date of change creation created = Column(TIMESTAMP(), server_default=functions.current_timestamp()) # user who made a change owner = Column(UUIDType(binary=False), ForeignKey('users.user_id')) __table_args__ = (PrimaryKeyConstraint(document_id, version),)
class Address(BaseModel): geo_api_id = db.Column(db.String(255), nullable=True, index=True) type = db.Column(db.String(20), nullable=True) coords = db.Column(db.ARRAY(db.Numeric), nullable=True) postal_code = db.Column(db.String(20), nullable=True) city = db.Column(db.String(255), nullable=True) name = db.Column(db.String(255), nullable=False) geo_api_raw_data = db.Column(JSONB(none_as_null=True), nullable=True) manual = db.Column(db.Boolean, nullable=False) @classmethod def get_or_create(cls, data): try: geo_api_id = data["properties"]["id"] properties = dict( type=data["properties"]["type"], postal_code=data["properties"]["postcode"], city=data["properties"]["city"], name=data["properties"]["name"], coords=data["geometry"]["coordinates"], ) except: raise InvalidParamsError("Could not parse GeoJSON payload") existing_addresses = cls.query.filter( cls.geo_api_id == geo_api_id ).all() for addr in existing_addresses: are_addresses_equal = True for key, value in properties.items(): if value != getattr(addr, key): are_addresses_equal = False break if are_addresses_equal: return addr address = cls( **properties, geo_api_id=geo_api_id, geo_api_raw_data=data, manual=False, ) db.session.add(address) return address def format(self): if self.manual: return self.name return f"{self.name} {self.postal_code} {self.city}"
class DelayedAction(Base): __tablename__ = 'delayed_actions' id = db.Column(db.Integer(), primary_key=True) created_at = db.Column(DateTime(), nullable=False) expires = db.Column(DateTime(), nullable=False, index=True) event = db.Column(db.String(), nullable=False) profile = db.Column(JSONB(), nullable=False, default={}) args: 'ArrayProperty[Any]' = db.ArrayProperty(default=[]) kwargs: 'ObjectProperty[Dict[str, Any]]' = db.ObjectProperty(default={}) @staticmethod async def get_active() -> Optional[DelayedAction]: return (await DelayedAction.query.order_by(DelayedAction.expires.asc() ).limit(1).gino.first()) @staticmethod async def get_by_event(event: str, *args: Any) -> Optional[DelayedAction]: query = DelayedAction.query.where(DelayedAction.event == event) for index, arg in enumerate(args): query = query.where( db.text( f"(delayed_actions.profile #> '{{args,{index}}}')::text " f"= '{arg}'")) return await query.gino.first() @staticmethod async def delete_by_id(id: int) -> Optional[DelayedAction]: return (await DelayedAction.delete.where(DelayedAction.id == id ).returning(*DelayedAction ).gino.first()) @staticmethod async def delete_by_event(event: str, *args: Any) -> Optional[DelayedAction]: query = DelayedAction.delete.where(DelayedAction.event == event) for index, arg in enumerate(args): query = query.where( db.text( f"(delayed_actions.profile #> '{{args,{index}}}')::text " f"= '{arg}'")) return await query.returning(*DelayedAction).gino.first()
class User(db.Model): __tablename__ = "users" id = db.Column(db.Text(), primary_key=True, default=id_generator("usr", 42)) created_at = db.Column( db.Integer(), nullable=False, default=lambda: int(time.time()) ) profile = db.Column(JSONB(), nullable=False, default={}) name = db.StringProperty() current_identity = None def get_user_id(self): return self.id def get_identity_id(self): return self.current_identity.id
class CardPosition(db.Model): __tablename__ = 'cardposition' id = db.Column('id', db.Integer, primary_key=True) key = db.Column(JSONB(astext_type=Text())) pageId = db.Column('pageid', db.Integer, db.ForeignKey('page.id')) page = db.relationship("Page") layoutId = db.Column('layoutid', db.Integer, db.ForeignKey('layout.id')) layout = db.relationship("Layout") userId = db.Column('userid', db.Integer, db.ForeignKey('user.id')) user = db.relationship("User") cardId = db.Column('cardid', db.Integer, db.ForeignKey('cards.id')) card = db.relationship("Card") position = db.Column('position', db.Integer) def __init__(self, userId, cardId, layoutId, pageId, position, key): self.userId = userId self.cardId = cardId self.layoutId = layoutId self.pageId = pageId self.position = position self.key = key def save(self): db.session.add(self) db.session.commit() @staticmethod def get_all(): return CardPosition.query def serialise(self): print(self.card) return { 'id': self.id, 'card': self.card.serialise(), 'page': self.page.serialise(), 'position': self.position, 'key': self.key }
class jsonb_change_key_name(expression.FunctionElement): """ Provides jsonb_change_key_name as a SQLAlchemy FunctionElement. :: import sqlalchemy as sa from postgresql_audit import jsonb_change_key_name data = {'key1': 1, 'key3': 4} query = sa.select([jsonb_merge(data, 'key1', 'key2')]) session.execute(query).scalar() # {'key2': 1, 'key3': 4} """ type = JSONB() name = 'jsonb_change_key_name'
class Token(db.Model): __tablename__ = 'tokens' class Actions: login = '******' id = db.Column(db.BigInteger(), primary_key=True) selector = db.Column(db.Unicode(), nullable=False, index=True, unique=True) validator = db.Column(db.Unicode(), nullable=False) created_at = db.Column(db.DateTime(), nullable=False) expires_at = db.Column(db.DateTime(), nullable=False) used_at = db.Column(db.DateTime()) profile = db.Column(JSONB(), nullable=False, server_default='{}') action = StringProperty() email = StringProperty() @classmethod def _split(cls, token): return token[:32], hashlib.shake_128(binascii.unhexlify( token[32:])).hexdigest(16) @classmethod @retry_on(UniqueViolationError) async def new(cls, ttl=timedelta(minutes=10), **payload): rv = hashlib.sha3_256(os.urandom(32)).hexdigest() selector, validator = cls._split(rv) now = datetime.utcnow() await cls.create(selector=selector, validator=validator, created_at=now, expires_at=now + ttl, **payload) return rv @classmethod async def verify(cls, token): selector, validator = cls._split(token) rv = await cls.query.where( cls.selector == selector, ).with_for_update().gino.first() if rv and (rv.validator != validator or rv.used_at or datetime.utcnow() > rv.expires_at): rv = None return rv async def use(self): await self.update(used_at=datetime.utcnow()).apply()
class IsxProfile(Base): __tablename__ = 'isx_profile' identity_id = Column(ForeignKey('isx_identity.identity_id', ondelete='CASCADE'), primary_key=True, nullable=False, index=True) application_id = Column(ForeignKey('isx_application.application_id', ondelete='CASCADE'), primary_key=True, nullable=False, index=True) profile_data = Column(JSONB(astext_type=Text())) application = relationship('IsxApplication') identity = relationship('IsxIdentity')
class Post(CommonModel): __tablename__ = 'post' post_name = db.Column(String()) post_type = db.Column(String()) thumbnail = db.Column(String()) images = db.Column(JSONB()) title = db.Column(String()) content = db.Column(String()) position = db.Column(Integer()) status = db.Column(String()) active = db.Column(Boolean(), nullable=True, default=True) note = db.Column(Text(), nullable=True) tenant_id = db.Column(String(), ForeignKey("tenant.id", onupdate="CASCADE", ondelete="RESTRICT"), nullable=False)
class Card(db.Model): __tablename__ = 'cards' id = db.Column(db.Integer, primary_key=True) order = db.Column(db.Integer) component = db.Column(db.String(255)) key = db.Column(JSONB(astext_type=Text())) data = db.Column(db.JSON) def __init__(self, component, key, data): self.component = component self.key = key self.data = data def save(self): db.session.add(self) db.session.commit() @staticmethod def get_all(): return Card.query @staticmethod def delete_all(): db.session.query(Card).delete() db.session.commit() def delete(self): db.session.delete(self) db.session.commit() def __repr__(self): return "<Card: {}>".format(self.id) def serialise(self): return { 'id': self.id, 'component': self.component, 'key': self.key, 'data': self.data, 'order': self.order }
class Highlight(Base): __tablename__ = 'highlights' resource_id = Column(ForeignKey('resources.id', ondelete='CASCADE'), nullable=False) content = Column(JSONB(astext_type=Text()), nullable=False) date = Column(DateTime(True), nullable=False, server_default=text("now()")) block_id = Column(ForeignKey('blocks.id', ondelete='CASCADE', onupdate='CASCADE'), nullable=False) id = Column(UUID(as_uuid=True), primary_key=True) user_id = Column(ForeignKey('users.id', ondelete='CASCADE'), nullable=False) block = relationship('Block') resource = relationship('Resource') user = relationship('User')
class Permission(CommonModel): __tablename__ = 'permission' role_id = db.Column( UUID(as_uuid=True), ForeignKey('role.id', ondelete="CASCADE", onupdate="CASCADE")) subject = db.Column(String, index=True) permission = db.Column(JSONB()) # read # value = db.Column(Boolean, default=False) # false tenant_id = db.Column(String(), ForeignKey("tenant.id", onupdate="RESTRICT", ondelete="RESTRICT"), nullable=False) __table_args__ = (UniqueConstraint( 'role_id', 'subject', 'permission', name='uq_permission_role_subject_permission'), )
class Provider(CommonModel): __tablename__ = 'provider' provider_name = db.Column(String()) provider_no = db.Column(String(), unique=True) images = db.Column(JSONB()) thumbnail = db.Column(Text()) description = db.Column(Text()) phone = db.Column(String()) email = db.Column(String()) address = db.Column(String()) services = db.relationship("Service", secondary="services_providers", lazy='dynamic') tenant_id = db.Column(String(), ForeignKey("tenant.id", onupdate="RESTRICT", ondelete="RESTRICT"), nullable=False)
class Slidestore(UserMixin, db.Model): __tablename__ = 'slidestore' slide_id = db.Column(db.Integer, primary_key=True) level = db.Column(db.Integer, nullable=False) course = db.Column(db.String(32), nullable=False) slide_type = db.Column(db.String(10), nullable=False) slide_name = db.Column(db.String(64), nullable=False) slide_path = db.Column(JSONB(), nullable=False) publisher = db.Column(db.String(32), nullable=False) def __init__(self, level, course, slide_type, slide_path, slide_name, publisher): self.level = level self.course = course self.slide_type = slide_type self.slide_name = slide_name self.slide_path = slide_path self.publisher = publisher
class Activity(db.Model): __tablename__ = "activity" id = db.Column(db.Integer, primary_key=True) actor = db.Column(db.Integer, db.ForeignKey("actor.id")) uuid = db.Column(UUID(as_uuid=True), server_default=sa_text("uuid_generate_v4()"), unique=True) url = db.Column(URLType(), unique=True, nullable=True) type = db.Column(db.String(100), index=True) box = db.Column(db.String(100)) payload = db.Column(JSONB()) creation_date = db.Column(db.DateTime(timezone=False), default=datetime.datetime.utcnow) delivered = db.Column(db.Boolean, default=None, nullable=True) delivered_date = db.Column(db.DateTime(timezone=False), nullable=True) local = db.Column(db.Boolean, default=True) meta_deleted = db.Column(db.Boolean, default=False) meta_undo = db.Column(db.Boolean, default=False) meta_pinned = db.Column(db.Boolean, default=False)
class Notifications(UserMixin, db.Model): __tablename__ = 'notifications' note_id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer) sender_name = db.Column(db.String(32)) note_header = db.Column(db.String(4)) note_content = db.Column(JSONB()) note_receiver = db.Column(db.Integer) timestamp = db.Column(db.DateTime, default=datetime.datetime.now()) seen = db.Column(db.String(1), nullable=True) def __init__(self, user_id, sender_name, note_header, note_content, note_receiver, timestamp): self.user_id = user_id self.note_header = note_header self.note_content = note_content self.note_receiver = note_receiver self.timestamp = timestamp self.sender_name = sender_name
class PurchaseOrder(CommonModel): __tablename__ = 'purchaseorder' id = db.Column(UUID(as_uuid=True), primary_key=True, default=default_uuid) tenant_id = db.Column(db.String) purchaseorder_no = db.Column(db.String) department = db.Column(db.String, nullable=True) organization_name = db.Column(db.String, nullable=True) organization_id = db.Column(db.String) tax_code = db.Column(db.String, nullable=True) address = db.Column(db.String, nullable=True) proponent = db.Column(db.String, nullable=True) #nguoi de nghi phone = db.Column(db.String, nullable=True) description = db.Column(Text(), nullable=True) payment_status = db.Column(String(20), default="pending") workstation_id = db.Column(db.String) workstation_name = db.Column(db.String) is_pos = db.Column(db.Boolean, default=False) # organization_name = db.Column(db.String) # organization_id = db.Column(db.String) net_amount = db.Column(DECIMAL(25, 8), default=0) # list_price * quantity amount = db.Column(DECIMAL(25, 8), default=0) # amount after it minus discount amount discount_percent = db.Column(DECIMAL(7, 3), default=0) # % giảm theo chương trình KM discount_amount = db.Column(DECIMAL(25, 8), default=0) # tiền giảm theo chương trình KM item_discount = db.Column(DECIMAL(25, 8), default=0) warehouse_id = db.Column(db.String) # payment = db.relationship("Payment", order_by="Payment.created_at", cascade="all, delete-orphan") details = db.relationship("ItemBalances", order_by="ItemBalances.created_at", cascade="all, delete-orphan") custom_fields = db.Column(JSONB(), nullable=True) # payment = db.relationship('PaymentDetails', secondary="paymentdetails_purchaseorder", cascade="save-update") paymentdetails = relationship('PaymentDetails')