class Exams(db.Model):
__tablename__ = "exams"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
subject_id = db.Column(db.Integer, db.ForeignKey(Subjects.id, ondelete="CASCADE"), nullable=False)
type_exam = db.Column(db.String(250), nullable=False)
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())
livecode = db.relationship("Livecodes", cascade="all, delete-orphan", passive_deletes=True)
quiz = db.relationship("Quizs", cascade="all, delete-orphan", passive_deletes=True)
history_exam = db.relationship("HistoriesExam", cascade="all, delete-orphan", passive_deletes=True)
response_fields = {
"id": fields.Integer,
"subject_id": fields.Integer,
"type_exam": fields.String,
"status": fields.Boolean,
"created_at": fields.DateTime,
"update_at": fields.DateTime
}
def __init__ (self, subject_id, type_exam, status):
self.subject_id = subject_id
self.type_exam = type_exam
self.status = status
def __rpr__(self):
return "<Users %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
class Phases(db.Model):
__tablename__ = "phases"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50), nullable=False, unique=True)
description = db.Column(db.Text)
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())
module = db.relationship("Modules",
cascade="all, delete-orphan",
passive_deletes=True)
history_phase = db.relationship("HistoriesPhase",
cascade="all, delete-orphan",
passive_deletes=True)
response_fields = {
"id": fields.Integer,
"name": fields.String,
"description": fields.String,
"status": fields.Boolean,
"created_at": fields.DateTime,
"update_at": fields.DateTime
}
def __init__(self, name, description, status):
self.name = name
self.description = description
self.status = status
def __rpr__(self):
return "<Users %r>" % self.id
class Transactions(db.Model):
__tablename__ = "transactions"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
product_id = db.Column(db.Integer,
db.ForeignKey('product.id'),
nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
phone_number = db.Column(db.String(15), nullable=False)
order_id = db.Column(db.String(255), default=None)
operator = db.Column(db.String(15), nullable=False, default=None)
label = db.Column(db.String(255), nullable=False, default=None)
nominal = db.Column(db.Integer, nullable=False)
price = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, nullable=False)
# PENDING PAID EXPIRED FAILED NOTPAID
payment_status = db.Column(db.String(20), default="BELUM DIBAYAR")
# PENDING SUCCESS FAILED PROCESSING
order_status = db.Column(db.String(20), default="BELUM DIPROSES")
trx_users = db.relationship('Users',
backref='transactions',
cascade="all",
lazy="joined")
trx_product = db.relationship('Product',
backref='transactions',
cascade="all",
lazy="joined")
trx_timedetail = db.relationship('Timedetails',
backref='transactions',
cascade="all",
lazy="joined")
response_fields = {
"id": fields.Integer,
"phone_number": fields.String,
"order_id": fields.String,
"product_id": fields.String,
"operator": fields.String,
"label": fields.String,
"nominal": fields.Integer,
"price": fields.Integer,
"created_at": fields.DateTime,
"payment_status": fields.String,
"order_status": fields.String
}
def __init__(self, user_id, phone_number, product_id, operator, label,
nominal, price, created_at):
self.user_id = user_id
self.phone_number = phone_number
self.product_id = product_id
self.operator = operator
self.label = label
self.nominal = nominal
self.price = price
self.created_at = created_at
class Users(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False)
phone = db.Column(db.String(15), nullable=False, unique=True)
email = db.Column(db.String(100), nullable=False, unique=True)
user_type = db.Column(db.String(100), nullable=False, default='user')
is_publisher = db.Column(db.String(10), nullable=False, default="false")
address = db.Column(db.Text(), nullable=True, default="")
profil_pict = db.Column(db.Text(), nullable=True, default="")
KTP_number = db.Column(db.String(100), nullable=True, default="")
KTP_pict = db.Column(db.Text(), nullable=True, default="")
password = db.Column(db.String(255))
salt = 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())
publishers = db.relationship("Publishers", cascade="all, delete-orphan", passive_deletes=True)
transaction = db.relationship("Transactions", cascade="all, delete-orphan", passive_deletes=True)
response_fields ={
'id' : fields.Integer,
'name' : fields.String,
'phone' : fields.String,
'email' : fields.String,
'user_type' : fields.String,
'is_publisher' : fields.String,
'address':fields.String,
'profil_pict':fields.String,
'KTP_number':fields.String,
'KTP_pict':fields.String,
'password' : fields.String,
'created_at' : fields.DateTime,
'updated_at' : fields.DateTime
}
jwt_claims_fields = {
'id' : fields.Integer,
'name' : fields.String,
'user_type' : fields.String,
}
def __init__(self, name, phone, email, user_type, password, salt):
self.name = name
self.phone = phone
self.email = email
self.user_type = user_type
self.password = password
self.salt = salt
def __repr__(self):
return '<User %r>'%self.id
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(30), nullable=False)
department_id = db.Column(db.Integer, db.ForeignKey('department.id'))
sub_categories = db.relationship('Subcategory',
backref='category',
lazy='dynamic')
products = db.relationship('Product', backref='category', lazy='dynamic')
def __init__(self, department_id, name):
self.name = name
self.department_id = department_id
class User(db.Model):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
full_name = db.Column(db.String(30), unique=True, nullable=False)
username = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(255), nullable=False, default=20)
salt = db.Column(db.String(255))
status = db.Column(db.String(50), nullable=False)
address = db.Column(db.String(255), nullable=False)
position = db.Column(db.String(50), nullable=False)
user_image = db.Column(db.String(2000), nullable=False)
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())
customer = db.relationship('Customer', backref='user', lazy=True)
user_contact = db.relationship('UserContact', backref='user', lazy=True)
leader_id = db.Column(db.Integer)
response_fields = {
'id': fields.Integer,
'full_name': fields.String,
'username': fields.String,
'password': fields.String,
'status': fields.String,
'address': fields.String,
'position': fields.String,
'user_image': fields.String,
'created_at': fields.DateTime,
'updated_at': fields.DateTime,
'leader_id': fields.Integer
}
jwt_claim_fields = {
'id': fields.Integer,
'username': fields.String,
'status': fields.String
}
def __init__(self, full_name, username, password, salt, status, address,
position, user_image, leader_id):
self.full_name = full_name
self.username = username
self.password = password
self.salt = salt
self.status = status
self.address = address
self.position = position
self.user_image = user_image
self.leader_id = leader_id
def __repr__(self):
return '<User %r>' % self.id
class Department(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(30), nullable=False, unique=True)
categories = db.relationship('Category',
backref='department',
lazy='dynamic')
sub_categories = db.relationship('Subcategory',
backref='department',
lazy='dynamic')
products = db.relationship('Product', backref='department', lazy='dynamic')
def __init__(self, name):
self.name = name
class Modules(db.Model):
__tablename__ = "modules"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
admin_id = db.Column(db.Integer,
db.ForeignKey(Admins.id, ondelete="CASCADE"),
nullable=False)
phase_id = db.Column(db.Integer,
db.ForeignKey(Phases.id, ondelete="CASCADE"),
nullable=False)
name = db.Column(db.String(250), nullable=False, unique=True)
description = db.Column(db.Text)
image = db.Column(db.String(255))
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())
review_module = db.relationship("ReviewsModule",
cascade="all, delete-orphan",
passive_deletes=True)
requirement_module = db.relationship("RequirementsModule",
cascade="all, delete-orphan",
passive_deletes=True)
subject = db.relationship("Subjects",
cascade="all, delete-orphan",
passive_deletes=True)
history_module = db.relationship("HistoriesModule",
cascade="all, delete-orphan",
passive_deletes=True)
response_fields = {
"id": fields.Integer,
"admin_id": fields.Integer,
"phase_id": fields.Integer,
"name": fields.String,
"description": fields.String,
"image": fields.String,
"status": fields.Boolean,
"created_at": fields.DateTime,
"update_at": fields.DateTime
}
def __init__(self, admin_id, phase_id, name, description, image, status):
self.admin_id = admin_id
self.phase_id = phase_id
self.name = name
self.description = description
self.image = image
self.status = status
def __rpr__(self):
return "<Users %r>" % self.id
class Products(db.Model):
__tablename__ = 'product'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100), nullable=False)
price = db.Column(db.Integer, nullable=False)
color = db.Column(db.String(100))
weight = db.Column(db.Integer, nullable=False) # gram
size = db.Column(db.String(10))
stock = db.Column(db.Integer, nullable=False)
promo = db.Column(db.Boolean, default=False)
discount = db.Column(db.Integer, default=0)
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())
product_type_id = db.Column(db.Integer, db.ForeignKey('product_type.id'))
seller_id = db.Column(db.Integer, db.ForeignKey('seller.id'))
pic_products = db.relationship('PicProducts', backref='product', lazy=True)
transaction_details = db.relationship(
'TransactionDetails', backref='product', lazy=True)
response_field = {
'id': fields.Integer,
'product_type_id': fields.Integer,
'seller_id': fields.Integer,
'name': fields.String,
'price': fields.Integer,
'color': fields.String,
'weight': fields.Integer,
'size': fields.String,
'stock': fields.Integer,
'promo': fields.Boolean,
'discount': fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime,
}
def __init__(self, name, price, color, weight, size, stock, promo, discount, product_type_id, seller_id):
self.name = name
self.price = price
self.color = color
self.weight = weight
self.size = size
self.stock = stock
self.promo = promo
self.discount = discount
self.product_type_id = product_type_id
self.seller_id = seller_id
def __repr__(self):
return '<Product %r>' % self.id
class Cards(db.Model):
__tablename__ = "cards"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
listId = db.Column(db.Integer,
db.ForeignKey("lists.id", ondelete='CASCADE'),
nullable=False)
text = db.Column(db.String(255), nullable=False)
order = db.Column(db.Integer, nullable=False)
description = db.Column(LONGTEXT(charset='latin1'))
members = db.Column(db.String(255))
code = db.Column(db.String(255))
labels = db.Column(db.String(255))
cover = 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())
cardId = db.relationship('CardMembers',
backref='cards',
lazy=True,
uselist=False,
cascade="all, delete-orphan",
passive_deletes=True)
cardId = db.relationship('CardLabels',
backref='cards',
lazy=True,
uselist=False,
cascade="all, delete-orphan",
passive_deletes=True)
response_fields = {
'id': fields.Integer,
'listId': fields.Integer,
'text': fields.String,
'order': fields.Integer,
'members': fields.String,
'code': fields.String,
'labels': fields.String,
'cover': fields.String,
}
def __init__(self, listId, text, order, code):
self.listId = listId
self.text = text
self.order = order
self.code = code
def __repr__(self):
return '<Cards %r>' % self.id
class UserModel(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(20), nullable=False, unique=True)
password = db.Column(db.String(255))
salt = db.Column(db.String(255))
status_internal = db.Column(db.Boolean, nullable=False)
status_penjual = db.Column(db.Boolean, nullable=False, default=False)
status_admin = db.Column(db.Boolean, nullable=False, default=False)
buyers = db.relationship('Buyers',
backref='users',
lazy=True,
uselist=False)
sellers = db.relationship('Sellers',
backref='users',
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,
'username': fields.String,
'password': fields.String,
'status_internal': fields.Boolean,
'status_penjual': fields.Boolean,
'status_admin': fields.Boolean
}
jwt_client_fields = {
'id': fields.Integer,
'username': fields.String,
'status_internal': fields.Boolean,
'status_penjual': fields.Boolean,
'status_admin': fields.Boolean,
}
def __init__(self, username, password, salt, status_internal,
status_penjual, status_admin):
self.username = username
self.password = password
self.status_internal = status_internal
self.status_penjual = status_penjual
self.status_admin = status_admin
self.salt = salt
def __repr__(self):
return '<User %r>' % self.id
class Users(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(30), nullable=False, unique=True)
username = db.Column(db.String(30), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False)
salt = db.Column(db.String(255))
bio = db.Column(db.String(255))
pict_profile = db.Column(db.String(255), default="https://pbs.twimg.com/profile_images/3182474033/c1d33595bce12b515bb83197eab2d9ba_400x400.jpeg")
pict_bg = db.Column(db.String(255), default="https://pbs.twimg.com/profile_images/3182474033/c1d33595bce12b515bb83197eab2d9ba_400x400.jpeg")
follower = db.Column(db.Integer, default=0)
following = db.Column(db.Integer, default=0)
status = db.Column(db.String(10), default='true')
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())
tweets = db.relationship('Tweets', backref='user', lazy=True)
followers = db.relationship('Followers', backref='user', lazy=True)
response_field = {
'id': fields.Integer,
'name': fields.String,
'username': fields.String,
'password': fields.String,
'bio': fields.String,
'pict_profile': fields.String,
'pict_bg': fields.String,
'follower':fields.Integer,
'following':fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
jwt_claim_fields = {
'id': fields.Integer,
'username': fields.String,
'status': fields.String
}
def __init__(self, name, username, password, bio, pict_profile, pict_bg, salt):
self.name = name
self.username = username
self.password = password
self.bio = bio
self.pict_profile = pict_profile
self.pict_bg = pict_bg
self.salt = salt
def __repr__(self):
return '<User %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 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 TransaksiDetail(db.Model):
__tablename__ = 'transaction_detail'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
transaction_id = db.Column(db.Integer, db.ForeignKey('table_transaksi.id'))
produk_id = db.Column(db.Integer, db.ForeignKey('table_produk.id'))
harga = db.Column(db.Integer, nullable=False)
qty = db.Column(db.Integer, 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_reviews = db.relationship(
'ReviewProduk', backref='transaction_detail', lazy=True)
response_field = {
'id': fields.Integer,
"pembeli_id": fields.Integer,
"produk_id": fields.Integer,
"harga": fields.Integer,
"qty": fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, transaction_id, produk_id, harga, qty):
self.transaction_id = transaction_id
self.produk_id = produk_id
self.harga = harga
self.qty = qty
def __repr__(self):
return '<TransactionDetail %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 Lokasi(db.Model):
__tablename__ = "table_lokasi"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
lokasi_restoran = db.Column(db.String(2000), unique=True, nullable=False)
table_restoran = db.relationship('Restoran',
backref="table_lokasi",
lazy=True)
lat = db.Column(db.Float)
lon = db.Column(db.Float)
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,
'lokasi_restoran': fields.String,
'lat': fields.Float,
'lon': fields.Float,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, lokasi_restoran, lat, lon):
self.lokasi_restoran = lokasi_restoran
self.lat = lat
self.lon = lon
def __repr__(self):
return '<Lokasi %r>' % self.id
class Quizs(db.Model):
__tablename__ = "quizs"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
modul_id = db.Column(db.Integer,
db.ForeignKey(Moduls.id, ondelete="CASCADE"),
nullable=False)
name_quiz = db.Column(db.String(200), nullable=False)
duration_minute = db.Column(db.Integer)
grade = db.Column(db.Integer)
question = db.relationship("Questions",
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,
"modul_id": fields.Integer,
"name_quiz": fields.String,
"duration_minute": fields.Integer,
"grade": fields.Integer,
"created_at": fields.DateTime,
"update_at": fields.DateTime,
}
def __init__(self, modul_id, name_quiz, duration_minute, grade):
self.modul_id = modul_id
self.name_quiz = name_quiz
self.duration_minute = duration_minute
self.grade = grade
def __rpr__(self):
return "<Quizs %r>" % self.id
class TransactionDetails(db.Model):
__tablename__ = 'transaction_detail'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
transaction_id = db.Column(db.Integer, db.ForeignKey('transaction.id'))
product_id = db.Column(db.Integer, db.ForeignKey('product.id'))
price = db.Column(db.Integer, nullable=False)
qty = db.Column(db.Integer, 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_review = db.relationship('ProductReviews', backref='transaction_detail', lazy=True)
response_field = {
'id':fields.Integer,
'transaction_id':fields.Integer,
'product_id':fields.Integer,
'price':fields.Integer,
'qty':fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, transaction_id, product_id, price, qty):
self.transaction_id = transaction_id
self.product_id = product_id
self.price = price
self.qty = qty
def __repr__(self):
return '<TransactionDetail %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 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 QuestionsAltatest(db.Model):
__tablename__ = "questions_altatest"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
admin_id = db.Column(db.Integer, db.ForeignKey(Admins.id, ondelete="CASCADE"), nullable=False)
question = db.Column(db.Text, nullable=False)
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())
choice_altatest = db.relationship("ChoicesAltatest", cascade="all, delete-orphan", passive_deletes=True)
response_fields = {
"id": fields.Integer,
"admin_id": fields.Integer,
"question": fields.String,
"status": fields.Boolean,
"created_at": fields.DateTime,
"update_at": fields.DateTime,
}
def __init__(self, admin_id, question, status):
self.admin_id = admin_id
self.question = question
self.status = status
def __rpr__(self):
return "<Questions %r>" % self.id
class GameVouchers(db.Model):
__tablename__ = "game_vouchers"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
game_id = db.Column(db.Integer, db.ForeignKey('games.id'))
voucher = db.Column(db.String(255), nullable=False)
price = db.Column(db.Integer, default=0)
transaction_details = db.relationship('TransactionDetails',
backref='game_vouchers',
lazy=True,
uselist=False,
cascade="all, delete-orphan")
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,
'game_id': fields.Integer,
'voucher': fields.String,
'price': fields.Integer
}
def __init__(self, game_id, voucher, price):
self.game_id = game_id
self.voucher = voucher
self.price = price
def __repr__(self):
return '<GameVouchers %r>' % self.id
class Submoduls(db.Model):
__tablename__ = "submoduls"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
modul_id = db.Column(db.Integer,
db.ForeignKey(Moduls.id, ondelete="CASCADE"),
nullable=False)
name_submodul = db.Column(db.String(200), nullable=False)
content = db.relationship("Contents",
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,
"modul_id": fields.Integer,
"name_submodul": fields.String,
"created_at": fields.DateTime,
"update_at": fields.DateTime,
}
def __init__(self, modul_id, name_submodul):
self.modul_id = modul_id
self.name_submodul = name_submodul
def __rpr__(self):
return "<Submoduls %r>" % self.id
class Quizs(db.Model):
__tablename__ = "quizs"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
exam_id = db.Column(db.Integer,
db.ForeignKey(Exams.id, ondelete="CASCADE"),
nullable=False)
name = db.Column(db.String(250))
description = db.Column(db.Text)
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())
questions_quiz = db.relationship("QuestionsQuiz",
cascade="all, delete-orphan",
passive_deletes=True)
response_fields = {
"id": fields.Integer,
"exam_id": fields.Integer,
"name": fields.String,
"description": fields.String,
"status": fields.Boolean,
"created_at": fields.DateTime,
"update_at": fields.DateTime,
}
def __init__(self, exam_id, name, description, status):
self.exam_id = exam_id
self.name = name
self.description = description
self.status = status
def __rpr__(self):
return "<Questions %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 BuyerModel(db.Model):
__tablename__ = "buyers"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
nama = db.Column(db.String(50), nullable=False)
email = db.Column(db.String(50), nullable=False)
alamat = db.Column(db.String(255))
no_hp = db.Column(db.String(15))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
cart = db.relationship('Carts', backref='buyers', 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,
'nama': fields.String,
'email': fields.String,
'alamat': fields.String,
'no_hp': fields.String,
'user_id':fields.Integer
}
def __init__(self, nama, email, alamat, no_hp, user_id):
self.nama = nama
self.email = email
self.alamat = alamat
self.no_hp = no_hp
self.user_id = user_id
def __repr__(self):
return '<Buyer %r>' % self.id
class Weeks(db.Model):
__tablename__ = "weeks"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
course_id = db.Column(
db.Integer, db.ForeignKey(Courses.id, ondelete="CASCADE"), nullable=False
)
name_week = db.Column(db.String(200), nullable=False)
duration_week = db.Column(db.Integer, default=7)
moduls = db.relationship(
"Moduls", 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,
"course_id": fields.Integer,
"name_week": fields.String,
"duration_week": fields.Integer,
"created_at": fields.DateTime,
"update_at": fields.DateTime,
}
def __init__(self, course_id, name_week):
self.course_id = course_id
self.name_week = name_week
def __rpr__(self):
return "<Weeks %r>" % self.id
class CartModel(db.Model):
__tablename__ = "carts"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
total_harga = db.Column(db.Integer, default=0)
total_kuantitas = db.Column(db.Integer, default=0)
ongkir = db.Column(db.Integer, default=0)
status_checkout = db.Column(db.Boolean, default=False)
seller_id = db.Column(db.Integer, db.ForeignKey('sellers.id'))
buyer_id = db.Column(db.Integer, db.ForeignKey('buyers.id'))
products = db.relationship('TransactionDetails',
backref='carts',
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,
'total_harga': fields.Integer,
'total_kuantitas': fields.Integer,
'ongkir': fields.Integer,
'seller_id': fields.Integer,
'buyer_id': fields.Integer,
'status_checkout': fields.Boolean,
'updated_at': fields.DateTime,
'created_at': fields.DateTime,
}
def __init__(self, seller_id, buyer_id):
self.seller_id = seller_id
self.buyer_id = buyer_id
def __repr__(self):
return '<Products %r>' % self.id
