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')
