class ChatList(db.Model):
__tablename__ = "chatlist"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
room_id = db.Column(db.Integer)
user_id = db.Column(db.Integer)
message = db.Column(db.String(500))
time = db.Column(db.String(500))
response_field = {
'id': fields.Integer,
'room_id': fields.Integer,
'user_id': fields.Integer,
'message': fields.String,
'time': fields.String,
}
def __init__(self, room_id, user_id, message, time):
self.room_id = room_id
self.user_id = user_id
self.message = message
self.time = time
def __repr__(self): #initiate table model
return '<ChatList %r>' % self.id
class Collections(db.Model):
__tablename__ = 'collection'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
book_id = db.Column(db.Integer,
db.ForeignKey('book.id', ondelete='CASCADE'),
nullable=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.now())
updated_at = db.Column(db.DateTime,
onupdate=datetime.datetime.now(),
default=datetime.datetime.now())
response_fields = {
'id': fields.Integer,
'user_id': fields.Integer,
'book_id': fields.Integer,
}
def __init__(self, user_id, book_id):
self.user_id = user_id
self.book_id = book_id
def __repr__(self):
return '<Collection %r>' % self.id
class Altatests(db.Model):
__tablename__ = "altatests"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
question_sum = db.Column(db.Integer)
status = db.Column(db.Boolean)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
altatest_history = db.relationship("HistoriesAltatest",
cascade="all, delete-orphan",
passive_deletes=True)
response_fields = {
"id": fields.Integer,
"question_sum": fields.Integer,
"status": fields.Boolean,
"created_at": fields.DateTime,
"update_at": fields.DateTime
}
def __init__(self, question_sum, status):
self.question_sum = question_sum
self.status = status
def __rpr__(self):
return "<Users %r>" % self.id
class Topics(db.Model):
# Define the property (each property associated with a column in database)
__tablename__ = 'topics'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
topic = db.Column(db.String(255), nullable=False, default='')
created_at = db.Column(
db.DateTime, default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
updated_at = db.Column(
db.DateTime, default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
deleted_at = db.Column(db.DateTime, nullable=True)
# The following dictionary is used to serialize "Topics" instances into JSON form
response_fields = {
'id': fields.Integer,
'topic': fields.String,
'created_at': fields.DateTime,
'updated_at': fields.DateTime,
'deleted_at': fields.DateTime
}
# Required fields when create new instances of "Topics" class
def __init__(self, topic):
self.topic = topic
# Reprsentative form to be shown in log
def __repr__(self):
return "Topic: " + self.topic
class Locs(db.Model):
__tablename__ = "location"
loc_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
nama_kabupaten = db.Column(db.String(100))
jenis_instansi = db.Column(db.String(100))
nama_instansi = db.Column(db.String(100))
alamat_instansi = db.Column(db.String(1500))
# ===== Respon Field =====
response_field = {
'loc_id': fields.Integer,
'nama_kabupaten': fields.String,
'jenis_instansi' : fields.String,
'nama_instansi' : fields.String,
'alamat_instansi' : fields.String
}
def __init__(self, loc_id, nama_kabupaten, jenis_instansi, nama_instansi, alamat_instansi):
self.loc_id = loc_id
self.nama_kabupaten = nama_kabupaten
self.jenis_instansi = jenis_instansi
self.nama_instansi = nama_instansi
self.alamat_instansi = alamat_instansi
def __repr__(self):
return '<Internal %r>' % self.loc_id
class ProductLike(db.Model):
__tablename__ = "product_like"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer,
ForeignKey(Users.id, ondelete='CASCADE'),
unique=True,
nullable=False)
product_id = db.Column(db.Integer,
ForeignKey(Product.id, ondelete='CASCADE'),
nullable=False)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
response_fields = {
'id': fields.Integer,
'user_id': fields.Integer,
'product_id': fields.Integer,
'created_at': fields.String,
'updated_at': fields.String
}
def __init__(self, user_id, product_id):
self.user_id = user_id
self.product_id = product_id
def __repr__(self):
return '<ProductLike %r>' % self.id
class Cartdetails(db.Model):
__tablename__ = "Cartdetail"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
id_cart = db.Column(db.Integer,
db.ForeignKey("Cart.id", ondelete='CASCADE'),
nullable=False)
id_product = db.Column(db.Integer,
db.ForeignKey("Product.id", ondelete='CASCADE'),
nullable=False)
quantity = db.Column(db.Integer, nullable=False, default=1)
deleted = db.Column(db.Boolean, nullable=False, default=False)
response_fields = {
'id': fields.Integer,
'id_cart': fields.Integer,
'id_product': fields.Integer,
'quantity': fields.Integer,
'deleted': fields.Boolean
}
def __init__(self, id_cart, id_product):
self.id_cart = id_cart
self.id_product = id_product
def __repr__(self):
return '<Cartdetail %r>' % self.id
class Menu(db.Model):
__tablename__ = "table_menu"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
nama_menu = db.Column(db.String(100), nullable=False, unique=True)
gambar_menu = db.Column(db.String(255))
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
table_restoran = db.relationship('Restoran',
backref="table_menu",
lazy=True)
response_fields = {
'id': fields.Integer,
'nama_menu': fields.String,
'gambar_menu': fields.String,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, nama_menu, gambar_menu):
self.nama_menu = nama_menu
self.gambar_menu = gambar_menu
def __repr__(self):
return '<Menu %r>' % self.id
class TransaksiDetails(db.Model):
__tablename__ = "TransaksiDetails"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
transaksi_id = db.Column(db.Integer,
db.ForeignKey("Transaksi.id"),
nullable=False)
produk_id = db.Column(db.Integer,
db.ForeignKey("Produk.id"),
nullable=False)
kuantitas = db.Column(db.Integer, nullable=False, default=1)
harga = db.Column(db.Integer, nullable=False)
response_fields = {
'id': fields.Integer,
'transaksi_id': fields.Integer,
'produk_id': fields.Integer,
'kuantitas': fields.Integer,
'harga': fields.Integer
}
def __init__(self, transaksi_id, produk_id, kuantitas, harga):
self.transaksi_id = transaksi_id
self.produk_id = produk_id
self.kuantitas = kuantitas
self.harga = harga
def __repr__(self):
return '<TransaksiDetails %r>' % self.id
class SubCategories(db.Model):
__tablename__ = "subcategory"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False, unique=True)
category_id = db.Column(db.Integer,
ForeignKey(Categories.id, ondelete='CASCADE'),
nullable=False)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
product = db.relationship("Products",
cascade="all, delete-orphan",
passive_deletes=True)
response_fields = {
'id': fields.Integer,
'name': fields.String,
'category_id': fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, name, category_id):
self.name = name
self.category_id = category_id
def __repr__(self):
return '<SubCategories %r>' % self.id
class Product_Types(db.Model):
__tablename__="Product_Types"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
nama = db.Column(db.String(255), nullable=False)
point = db.Column(db.Integer)
# created_at = db.Column(db.DataTime)
# updated_at = db.Column(db.DataTime)
# deleted_at = db.Column(db.DataTime)
respond_field = {
'id' : fields.Integer,
'nama' : fields.String,
'point' : fields.String
# 'created_at' : fields.DataTime,
# 'updated_at' : fields.DataTime,
# 'deleted_at' : fields.DataTime
}
def __init__(
self, id, nama, point
): # created_at, updated_at, deleted_at
self.id = id
self.nama = nama
self.point = point
# self.created_at = created_at
# self.updated_at = updated_at
# self.deleted_at = deleted_at
def __repr__(self):
return '<Product_Types %r>' % self.id
class Price(db.Model):
__tablename__ = "prices"
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
product_id = db.Column(db.Integer,
db.ForeignKey("products.id"),
nullable=False)
unit_price = db.Column(db.Integer, nullable=False, default=0)
unit_sale_price = db.Column(db.Integer, nullable=False, default=0)
created = db.Column(db.DateTime, nullable=False)
product = relationship("Product", back_populates="price")
response = {
"created": fields.DateTime(dt_format="iso8601"),
"id": fields.Integer,
"product_id": fields.Integer,
"unit_price": fields.Integer,
"unit_sale_price": fields.Integer
}
def __init__(self, product_id, unit_price, unit_sale_price):
self.product_id = product_id
self.unit_price = unit_price
self.unit_sale_price = unit_sale_price
self.created = datetime.now()
def __repr__(self):
return "<Price %r>" % self.id
class Description(db.Model):
__tablename__ = "descriptions"
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
content = db.Column(db.String(5000), nullable=False, default="")
created = db.Column(db.DateTime, nullable=False)
link = db.Column(db.String(100), nullable=False, default="")
product = relationship("Product", back_populates="description")
response = {
"created": fields.DateTime(dt_format="iso8601"),
"id": fields.Integer,
"content": fields.String,
"link": fields.String
}
def __init__(self, content, link):
self.content = content
self.link = link
self.created = datetime.now()
def __repr__(self):
return "<Description %r>" % self.id
class Photo(db.Model):
__tablename__ = "photos"
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
product_id = db.Column(db.Integer,
db.ForeignKey("products.id"),
nullable=False)
source = db.Column(db.String(1000), nullable=False, default="")
created = db.Column(db.DateTime, nullable=False)
product = relationship("Product", back_populates="photo")
response = {
"created": fields.DateTime(dt_format="iso8601"),
"id": fields.Integer,
"product_id": fields.Integer,
"source": fields.String
}
def __init__(self, product_id, source):
self.product_id = product_id
self.source = source
self.created = datetime.now()
def __repr__(self):
return "<Photo %r>" % self.id
class Users(db.Model):
__tablename__ = "Users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(50), unique=True, nullable=False)
email = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False)
response_fields = {
'id': fields.Integer,
'username': fields.String,
'email': fields.String,
'password': fields.String
}
jwt_claims_fields = {
'id': fields.Integer,
'username': fields.String,
'email': fields.String,
# 'isadmin' : fields.Boolean
}
def __init__(self, username, email, password):
self.username = username
self.email = email
self.password = password
def __repr__(self):
return '<Users %r>' % self.id
class CommentsLike(db.Model):
__tablename__ = "commentsLike"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
id_comment = db.Column(db.Integer)
liked_by = db.Column(db.Integer)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
response_field = {
'id': fields.Integer,
'id_comment': fields.Integer,
'liked_by': fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, id, id_comment, liked_by, created_at, updated_at):
self.id = id
self.id_comment = id_comment
self.liked_by = liked_by
self.created_at = created_at
self.updated_at = updated_at
def __repr__(self):
return '<CommentsLike %r>' % self.id
class CustomerMember(db.Model):
__tablename__ = "customer_member"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
customer_id = db.Column(db.Integer,
db.ForeignKey(Customer.id, ondelete="CASCADE"))
group_id = db.Column(db.Integer, db.ForeignKey('customer_group.id'))
created_at = db.Column(db.DateTime(timezone=True),
server_default=db.func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=db.func.now())
response_fields = {
'id': fields.Integer,
'customer_id': fields.Integer,
'group_id': fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime,
}
def __init__(self, customer_id, group_id):
self.customer_id = customer_id
self.group_id = group_id
def __repr__(self):
return '<CustomerMember %r>' % self.id
class Cart(db.Model):
__tablename__ = 'cart'
cart_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
nullable=False)
item_id = db.Column(db.Integer,
db.ForeignKey('item.item_id'),
nullable=False)
qty = db.Column(db.Integer, nullable=False)
harga = db.Column(db.Integer, nullable=False)
response_fields = {
'cart_id': fields.Integer,
'user_id': fields.Integer,
'item_id': fields.Integer,
'qty': fields.Integer,
'harga': fields.Integer
}
def __init__(self, item_id, user_id, qty, harga):
self.item_id = item_id
self.user_id = user_id
self.qty = qty
self.harga = harga
def __repr__(self):
return '<Cart %r>' % self.cart_id
class Token(db.Model):
id = db.Column(db.Integer, primary_key=True)
token = db.Column(db.String(32), index=True, unique=True)
token_expiration = db.Column(db.DateTime)
# based on code from Miguel Grinberg's Flask Mega Tutorial
def make_token(self, expires_in=10):
now = datetime.utcnow()
if self.token and self.token_expiration > now + timedelta(seconds=60):
return self.token
self.token = base64.b64encode(os.urandom(24)).decode('utf-8')
self.token_expiration = now + timedelta(seconds=expires_in)
db.session.add(self)
return self.token
def revoke_token(self):
self.token_expiration = datetime.utcnow() - timedelta(seconds=1)
@staticmethod
def check_token(token):
token = Token.query.filter_by(token=token).first()
if token is None or token.token_expiration < datetime.utcnow():
return None
return token
class Users(db.Model):
__tablename__ = 'user'
user_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(30), unique=True, nullable=False)
email = db.Column(db.String(30), unique=True, nullable=False)
password = db.Column(db.String(30), nullable=False)
status = db.Column(db.Boolean, nullable=False)
response_fields = {
'user_id': fields.Integer,
'username': fields.String,
'email': fields.String,
'password': fields.String,
'status': fields.Boolean
}
jwt_response_field = {
'username': fields.String,
'email': fields.String,
'status': fields.Boolean
}
def __init__(self, username, email, password, status):
self.username = username
self.email = email
self.password = password
self.status = status
def __repr__(self):
return '<User %r>' % self.user_id
class Conversations(db.Model):
__tablename__ = "conversations"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user1_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user2_id = db.Column(db.Integer, db.ForeignKey('users.id'))
# status_deleted = db.Column(db.Boolean, nullable=False)
personal_message = db.relationship('PersonalMessages', backref='conversations', lazy=True, uselist=False)
created_at = db.Column(db.DateTime(timezone=True),server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
response_fields = {
'id':fields.Integer,
'user1_id':fields.Integer,
'user2_id':fields.Integer,
# 'status_deleted':fields.Boolean
'created_at':fields.DateTime
}
def __init__(self, user1_id, user2_id):
self.user1_id = user1_id
self.user2_id = user2_id
# self.status_deleted = status_deleted
def __repr__(self):
return '<Conversation %r>' % self.id
class PopProducts(db.Model):
__tablename__ = "pop_product"
id = db.Column(
db.Integer,
primary_key=True) #product id diambil dari id table product.
# product_id = db.Column(db.Integer, nullable=False)
name = db.Column(
db.String(255), nullable=False
) #nama product diambil dari table product melalui product_id
penjual = db.Column(
db.String(255), nullable=False
) #nama penjual diambil dari table product melalui product_id
terjual = db.Column(
db.Integer, nullable=False
) #minimum untuk jadi popular product adalah ketika terbeli sudah mencapai 25
response_field = {
'id': fields.Integer,
'name': fields.String,
'penjual': fields.String,
'terjual': fields.String,
}
def __init__(self, id, name, penjual, terjual):
self.id = id
self.name = name
self.penjual = penjual
self.terjual = terjual
def __repr__(self): #initiate table model
return '<Pop_Product %r>' % self.id #the __repr__ must have a string type as return
class Feedbacks(db.Model):
__tablename__ = "feedback"
fb_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
unique=True)
user_id = db.Column(db.Integer)
email = db.Column(db.String(200))
feedback = db.Column(db.String(1000))
response_fields = {
'fb_id': fields.Integer,
'user_id': fields.Integer,
'email': fields.String,
'feedback': fields.String
}
def __init__(self, fb_id, user_id, email, feedback):
self.fb_id = fb_id
self.user_id = user_id
self.email = email
self.feedback = feedback
def __repr__(self):
return '<Feedback %r>' % self.id
class Clients(db.Model):
__tablename__ = "clients"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
client_key = db.Column(db.String(50), unique=True, nullable=False)
client_secret = db.Column(db.String(255))
salt = db.Column(db.String(255))
status = db.Column(db.String(30), default=0)
users = db.relationship('Users',
backref='clients',
lazy=True,
uselist=False)
response_fields = {
'id': fields.Integer,
'client_key': fields.String,
'client_secret': fields.String,
'status': fields.String
}
jwt_claims_fields = {'client_key': fields.String, 'status': fields.String}
#urutan ini harus sesuai dengan def post result
def __init__(self, client_key, client_secret, status, salt):
self.client_key = client_key
self.status = status
self.client_secret = client_secret
self.salt = salt
def __repr__(self):
return '<Client %r>' % self.id
class Questions(db.Model):
__tablename__ = "questions"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
quiz_id = db.Column(db.Integer,
db.ForeignKey(Quizs.id, ondelete="CASCADE"),
nullable=False)
question = db.Column(db.String(2000), nullable=False)
choice = db.relationship("Choices",
cascade="all, delete-orphan",
passive_deletes=True)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
response_fields = {
"id": fields.Integer,
"quiz_id": fields.Integer,
"question": fields.String,
"created_at": fields.DateTime,
"update_at": fields.DateTime,
}
def __init__(self, quiz_id, question):
self.quiz_id = quiz_id
self.question = question
def __rpr__(self):
return "<Questions %r>" % self.id
class Getjob(db.Model):
__tablename__ = 'getjob'
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
unique=True)
tipe = db.Column(db.String(100))
lokasi = db.Column(db.String(100))
deskripsi = db.Column(db.String(100))
lamar = db.Column(db.String(255))
response_field = { #pengganti serialize
'id': fields.Integer,
'tipe': fields.String,
'lokasi': fields.String,
'deskripsi': fields.String,
'lamar': fields.String
}
def __init__(self, id, tipe, lokasi, deskripsi, lamar):
self.id = id
self.tipe = tipe
self.lokasi = lokasi
self.deskripsi = deskripsi
self.lamar = lamar
def __repr__(self):
return '<getjob %r>' % self.id #Book itu hanya penamaan, harus string
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
email = db.Column(db.String, nullable=False)
uuid = db.Column(db.String, nullable=False)
provider = db.Column(db.String, nullable=False)
def __init__(self, uuid, email, provider, name):
self.uuid = uuid
self.name = name
self.email = email
self.provider = provider
@classmethod
def by_google_uuid(cls, uuid):
return cls.query.filter_by(provider='google').filter_by(
uuid=uuid).first()
@classmethod
def by_facebook_uuid(cls, uuid):
return cls.query.filter_by(provider='facebook').filter_by(
uuid=uuid).first()
@classmethod
def by_id(cls, query):
return cls.query.filter_by(id=query).first()
class Transaksi_detail(db.Model):
__tablename__ = 'transaksi_detail'
transaksi_detail_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True)
transaksi_id = db.Column(db.Integer,
db.ForeignKey('transaksi.transaksi_id'),
nullable=False,
unique=True)
item_id = db.Column(db.Integer, nullable=False)
qty = db.Column(db.Integer, nullable=False)
harga = db.Column(db.Integer, nullable=False)
response_fields = {
'transaksi_detail_id': fields.Integer,
'transaksi_id': fields.Integer,
'item_id': fields.Integer,
'qty': fields.Integer,
'harga': fields.Integer
}
def __init__(self, transaksi_id, item_id, qty, harga):
self.transaksi_id = transaksi_id
self.item_id = item_id
self.qty = qty
self.harga = harga
def __repr__(self):
return '<Transaksi_detail %r>' % self.transaksi_detail_id
class Recipe(db.Model):
__tablename__ = "recipe"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
id_inventory = db.Column(db.Integer,
db.ForeignKey("inventories.id",
ondelete='CASCADE'),
nullable=False)
id_product = db.Column(db.Integer,
db.ForeignKey("products.id", ondelete='CASCADE'),
nullable=False)
amount = db.Column(db.Integer, nullable=False, default=0)
response_fields = {
'id': fields.Integer,
'id_inventory': fields.Integer,
'id_product': fields.Integer,
'amount': fields.Integer
}
def __init__(self, id_inventory, id_product, amount):
self.id_inventory = id_inventory
self.id_product = id_product
self.amount = amount
def __repr__(self):
return '<Recipe %r>' % self.id
class Categories(db.Model):
__tablename__ = "category"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
imgURL = db.Column(db.String(255))
name = db.Column(db.String(100), nullable=False, unique=True)
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
product = db.relationship("Products",
cascade="all, delete-orphan",
passive_deletes=True)
subcategory = db.relationship("SubCategories",
cascade="all, delete-orphan",
passive_deletes=True)
response_fields = {
'id': fields.Integer,
'imgURL': fields.String,
'name': fields.String,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, imgURL, name):
self.imgURL = imgURL
self.name = name
def __repr__(self):
return '<Categories %r>' % self.id
