class Cart(db.Model):
__tablename__ = "Cart"
id = db.Column(db.Integer, primary_key=True,
autoincrement=True) # unique=True
idTransaksi = db.Column(db.Integer, nullable=False)
pembeli_id = db.Column(db.Integer, nullable=False)
namaPembeli = db.Column(db.String(255), nullable=False)
produk_id = db.Column(db.Integer, nullable=False)
namaProduk = db.Column(db.String(255), nullable=False)
gambarProduk = db.Column(db.String(255), nullable=False)
qty = db.Column(db.Integer, nullable=False)
hargaSatuan = db.Column(db.Integer, nullable=False)
totalHarga = db.Column(db.Integer, nullable=False)
status = db.Column(db.String(10), nullable=False)
response_field = {
'id': fields.Integer,
'idTransaksi': fields.Integer,
'pembeli_id': fields.Integer,
'namaPembeli': fields.String,
'produk_id': fields.Integer,
'namaProduk': fields.String,
'gambarProduk': fields.String,
'qty': fields.Integer,
'hargaSatuan': fields.Integer,
'totalHarga': fields.Integer,
'status': fields.String,
}
response_cart = {
'id': fields.Integer,
'idTransaksi': fields.Integer,
'namaPembeli': fields.String,
'namaProduk': fields.String,
'gambarProduk': fields.String,
'qty': fields.Integer,
'hargaSatuan': fields.Integer,
'totalHarga': fields.Integer,
'status': fields.String
}
def __init__(self, id, pembeli_id, namaPembeli, produk_id, namaProduk,
gambarProduk, qty, hargaSatuan, totalHarga, status,
idTransaksi):
self.id = id
self.pembeli_id = pembeli_id
self.namaPembeli = namaPembeli
self.produk_id = produk_id
self.namaProduk = namaProduk
self.gambarProduk = gambarProduk
self.qty = qty
self.hargaSatuan = hargaSatuan
self.totalHarga = totalHarga
self.status = status
self.idTransaksi = idTransaksi
def __repr__(self): # return dari repr harus string
return '<Cart %r>' % self.id
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
sub_name = db.Column(db.String(255), nullable=False)
price = db.Column(db.Integer, default=None)
discount = db.Column(db.Integer, default=0)
sell_price = db.Column(db.Integer, default=None)
image_path = db.Column(db.String(1000), default=None)
seller_id = db.Column(db.Integer,
db.ForeignKey('Seller.id', ondelete='CASCADE'),
nullable=False)
department_id = db.Column(db.Integer, db.ForeignKey('department.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
subcategory_id = db.Column(db.Integer, db.ForeignKey('subcategory.id'))
stock = db.relationship('Stock', backref='product')
# field dari product yang nantinya akan diinfokan ke seller
seller_fields = {
'id': fields.Integer,
'department_id': fields.Integer,
'category_id': fields.Integer,
'subcategory_id': fields.Integer,
'name': fields.String,
'sub_name': fields.String,
'price': fields.Integer,
'discount': fields.Integer,
'sell_price': fields.Integer,
'image_path': fields.String
}
cust_fields = {
'id': fields.Integer,
'department_id': fields.Integer,
'category_id': fields.Integer,
'subcategory_id': fields.Integer,
'name': fields.String,
'sub_name': fields.String,
'price': fields.Integer,
'discount': fields.Integer,
'sell_price': fields.Integer,
'image_path': fields.String
}
def __init__(self, department_id, category_id, subcategory_id, name,
sub_name, price, discount, sell_price, seller_id, image_path):
self.department_id = department_id,
self.category_id = category_id,
self.subcategory_id = subcategory_id
self.name = name,
self.sub_name = sub_name,
self.price = price,
self.discount = discount,
self.sell_price = sell_price,
self.seller_id = seller_id,
self.image_path = image_path
def __repr__(self):
return '<Product %r>' % self.name
class Products(db.Model):
__tablename__ = "Product"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
id_seller = db.Column(db.Integer,
db.ForeignKey("Seller.id", ondelete='CASCADE'),
nullable=False)
name_product = db.Column(db.String(255), nullable=False, default="")
description = db.Column(db.String(255), nullable=False, default="")
rating = db.Column(db.Integer, nullable=False, default=0)
weight = db.Column(db.Integer, nullable=False, default=0)
price = db.Column(db.Integer, nullable=False, default=0)
reference = db.Column(db.String(16), nullable=False, default="")
stock = db.Column(db.Integer, nullable=False, default=0)
halal = db.Column(db.Boolean, nullable=False, default=False)
taste = db.Column(db.String(16), nullable=False, default="")
sold = db.Column(db.Integer, nullable=False, default=0)
image = db.Column(db.String(255), nullable=False, default="")
deleted = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(db.DateTime, default=datetime.datetime.now())
update_at = db.Column(db.DateTime, onupdate=datetime.datetime.now())
response_fields = {
'id': fields.Integer,
'id_seller': fields.Integer,
'name_product': fields.String,
'description': fields.String,
'rating': fields.Integer,
'weight': fields.Integer,
'price': fields.Integer,
'reference': fields.String,
'stock': fields.String,
'halal': fields.Boolean,
'taste': fields.String,
'sold': fields.Integer,
'image': fields.String,
'deleted': fields.Boolean,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, id_seller, name_product, description, weight, price,
reference, stock, halal, taste, image):
self.id_seller = id_seller
self.name_product = name_product
self.description = description
self.weight = weight
self.price = price
self.reference = reference
self.stock = stock
self.halal = halal
self.taste = taste
self.image = image
def __repr__(self):
return '<Product %r>' % self.id
class Employees(db.Model):
__tablename__ = 'employees'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
id_outlet = db.Column(db.Integer,
db.ForeignKey('outlets.id'),
nullable=False)
username = db.Column(db.String(100), nullable=False, unique=True)
full_name = db.Column(db.String(150), nullable=False, default='')
position = db.Column(db.String(20), nullable=False, default='')
password = db.Column(db.String(190), nullable=False, default='')
created_at = db.Column(
db.DateTime,
nullable=False,
default=(datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S"))
updated_at = db.Column(
db.DateTime,
nullable=False,
default=(datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S"))
deleted = db.Column(db.Boolean, default=False)
# JWT required claims
jwt_claim_fields = {
'id': fields.Integer,
'id_outlet': fields.Integer,
'username': fields.String,
'position': fields.String,
'deleted': fields.Boolean
}
# Responsive employee fields
response_fields = {
'id': fields.Integer,
'id_outlet': fields.Integer,
'username': fields.String,
'full_name': fields.String,
'position': fields.String,
'password': fields.String,
'created_at': fields.DateTime,
'updated_at': fields.DateTime,
'deleted': fields.Boolean
}
# required fields when create new data
def __init__(self, id_outlet, full_name, username, password, position):
self.id_outlet = id_outlet
self.full_name = full_name
self.username = username
self.password = password
self.position = position
# for display log this table
def __repr__(self):
return '<Employees %r>' % self.username
class Products(db.Model):
__tablename__ = "products"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
shop_id = db.Column(db.Integer, db.ForeignKey("shops.id"))
name = db.Column(db.String(255), default='')
price = db.Column(db.Integer, default=0)
category = db.Column(db.String(255), default='')
subcategory = db.Column(db.String(255), default='')
image = db.Column(db.String(255), default='')
limited = db.Column(db.Boolean, default=False)
description = db.Column(db.String(255), default='')
sold = db.Column(db.Integer, default=0)
stock = db.Column(db.Integer, default=1)
promo = db.Column(db.Boolean, default=False)
discount = db.Column(db.Integer, default=0)
weight = db.Column(db.Integer, default=0)
status = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime, default=datetime.now())
updated_at = db.Column(db.DateTime, default=datetime.now())
response_fields = {
"created_at": fields.DateTime,
"updated_at": fields.DateTime,
"id": fields.Integer,
"shop_id": fields.Integer,
"name": fields.String,
"price": fields.Integer,
"category": fields.String,
"subcategory": fields.String,
"image": fields.String,
"limited": fields.Boolean,
"description": fields.String,
"sold": fields.Integer,
"stock": fields.Integer,
"promo": fields.Boolean,
"discount": fields.Integer,
"weight": fields.Integer,
"status": fields.Boolean
}
def __init__(self, shop_id, name, price, category, subcategory, image,
limited, description, stock, weight):
self.shop_id = shop_id
self.name = name
self.price = price
self.category = category
self.subcategory = subcategory
self.image = image
self.limited = limited
self.description = description
self.stock = stock
self.weight = weight
def __repr__(self):
return "<Products %r>" % self.id
class Inventories(db.Model):
__tablename__ = 'inventories'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
id_users = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete='CASCADE'),
nullable=False)
name = db.Column(db.String(150), nullable=False, default='')
total_stock = db.Column(db.Integer, nullable=False, default=0)
unit = db.Column(db.String(20), nullable=False, default='')
unit_price = db.Column(db.Integer, nullable=False, default=0)
times_edited = db.Column(db.Integer, nullable=False, default=0)
created_at = db.Column(
db.DateTime,
nullable=False,
default=(datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S"))
updated_at = db.Column(
db.DateTime,
nullable=False,
default=(datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S"))
deleted = db.Column(db.Boolean, default=False)
# responsive inventory fields
inventories_fields = {
'id': fields.Integer,
'id_users': fields.Integer,
'name': fields.String,
'total_stock': fields.Integer,
'unit': fields.String,
'unit_price': fields.Integer,
'times_edited': fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime,
'deleted': fields.Boolean
}
# required fields when create new data
def __init__(self, id_users, name, total_stock, unit, unit_price,
times_edited):
self.id_users = id_users
self.name = name
self.total_stock = total_stock
self.unit = unit
self.unit_price = unit_price
self.times_edited = times_edited
self.created_at = (datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S")
self.updated_at = (datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S")
self.deleted = False
# for display log this table
def __repr__(self):
return '<Inventories %r>' % self.name
class Pembeli(db.Model):
__tablename__ = "pembeli"
id_pembeli = db.Column(db.Integer, primary_key=True)
nama_pembeli = db.Column(db.String(255), nullable=False)
user_name = db.Column(db.String(100), nullable=False)
contact_pembeli = db.Column(db.String(100), nullable=False)
email_pembeli = db.Column(db.String(30), nullable=False)
password_pembeli = db.Column(db.String(30), nullable=False)
status = db.Column(db.Boolean, nullable=False)
response_fields = {
'id_pembeli': fields.Integer,
'nama_pembeli': fields.String,
'user_name': fields.String,
'contact_pembeli': fields.String,
'email_pembeli': fields.String,
'password_pembeli': fields.String,
'status': fields.Boolean
}
jwt_response_fields = {
'id_pembeli': fields.Integer,
'nama_pembeli': fields.String,
'user_name': fields.String,
'contact_pembeli': fields.String,
'email_pembeli': fields.String,
'status': fields.Boolean
}
def __init__(self, nama_pembeli, user_name, contact_pembeli, email_pembeli,
password_pembeli, status):
self.nama_pembeli = nama_pembeli
self.user_name = user_name
self.contact_pembeli = contact_pembeli
self.email_pembeli = email_pembeli
self.password_pembeli = password_pembeli
self.status = status
def __repr__(self):
return '<User %r>' % self.id_pembeli
@classmethod
def is_exists(cls, data):
all_data = cls.query.all()
existing_nama_pembeli = [item.nama_pembeli for item in all_data]
if data in existing_nama_pembeli:
return True
return False
class Categories(db.Model):
"""class for category"""
__tablename__ = "categories"
preference = db.Column(db.String(100), nullable=False, primary_key=True)
category = db.Column(db.String(100), nullable=False)
response_fields = {'preference': fields.String, 'category': fields.String}
def __init__(self, preference, category):
self.preference = preference
self.category = category
class Recipes(db.Model):
__tablename__ = "recipes"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
userID = db.Column(db.Integer, nullable=False)
methodID = db.Column(db.Integer, nullable=False)
originID = db.Column(db.Integer, nullable=False)
name = db.Column(db.String(50), nullable=False)
beanName = db.Column(db.String(30), nullable=False)
beanProcess = db.Column(db.String(30), nullable=False)
beanRoasting = db.Column(db.String(30), nullable=False)
rating = db.Column(db.Float, nullable=False, default=0)
reviewCount = db.Column(db.Integer, nullable=False, default=0)
brewCount = db.Column(db.Integer, nullable=False, default=0)
difficulty = db.Column(db.Integer, nullable=False)
createdAt = db.Column(db.DateTime, nullable=False, default=datetime.now)
time = db.Column(db.Integer, nullable=False)
coffeeWeight = db.Column(db.Integer, nullable=False)
water = db.Column(db.Integer, nullable=False)
responseFields = {
'id': fields.Integer,
'userID': fields.Integer,
'methodID': fields.Integer,
'originID': fields.Integer,
'name': fields.String,
'beanName': fields.String,
'beanProcess': fields.String,
'beanRoasting': fields.String,
'rating': fields.Float,
'reviewCount': fields.Integer,
'brewCount': fields.Integer,
'difficulty': fields.Integer,
'createdAt': fields.DateTime,
'time': fields.Integer,
'coffeeWeight': fields.Integer,
'water': fields.Integer,
}
def __init__(self, userID, name, methodID, originID, beanName, beanProcess,
beanRoasting, difficulty, time, coffeeWeight, water):
self.userID = userID
self.name = name
self.methodID = methodID
self.originID = originID
self.beanName = beanName
self.beanProcess = beanProcess
self.beanRoasting = beanRoasting
self.difficulty = difficulty
self.time = time
self.coffeeWeight = coffeeWeight
self.water = water
class Pemain(db.Model):
__tablename__ = 'pemain'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(50), unique=True)
password = db.Column(db.String(50))
name = db.Column(db.String(100))
email = db.Column(db.String(100))
phone_no = db.Column(db.String(100))
address = db.Column(db.String(100))
favourite_sport = db.Column(db.String(100))
user_type = db.Column(db.String(100))
created_time = db.Column(db.String(100))
url_image = db.Column(db.String(1000))
is_google = db.Column(db.Integer)
balance = db.Column(db.Integer)
response_field = {
'id': fields.Integer,
'username': fields.String,
'password': fields.String,
'name': fields.String,
'email': fields.String,
'phone_no': fields.String,
'address': fields.String,
'favourite_sport': fields.String,
'user_type': fields.String,
'created_time': fields.String,
'url_image': fields.String,
'is_google': fields.Integer,
'balance': fields.Integer,
}
def __init__(self, username, password, name, email, phone_no, address,
favourite_sport, user_type, created_time, url_image,
is_google, balance):
self.username = username
self.password = password
self.name = name
self.email = email
self.phone_no = phone_no
self.address = address
self.favourite_sport = favourite_sport
self.user_type = user_type
self.created_time = created_time
self.url_image = url_image
self.is_google = is_google
self.balance = balance
def __repr__(self):
return '<Pemain %r>' % self.id
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 Event(db.Model):
__tablename__ = "event"
event_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
band_id = db.Column(db.Integer, nullable=False)
bandName = db.Column(db.String(100), nullable=False)
event_name = db.Column(db.String(100), nullable=False)
price = db.Column(db.Integer, nullable=False)
location = db.Column(db.String(100), nullable=False)
quantity = db.Column(db.Integer, nullable=False)
event_desc = db.Column(db.String(500), nullable=False)
event_photo = db.Column(db.String(100), nullable=False)
response_field = {
'event_id': fields.Integer,
'band_id': fields.Integer,
'bandName': fields.String,
'event_name': fields.String,
'price': fields.Integer,
'location': fields.String,
'quantity': fields.Integer,
'event_desc': fields.String,
'event_photo': fields.String
}
public_response_field = {
'event_id': fields.Integer,
'bandName': fields.String,
'band_id': fields.Integer,
'event_name': fields.String,
'price': fields.Integer,
'location': fields.String,
'quantity': fields.Integer,
'event_desc': fields.String,
'event_photo': fields.String
}
def __init__(self, event_id, band_id, bandName, event_name, price,
location, quantity, event_desc, event_photo):
self.event_id = event_id
self.band_id = band_id
self.bandName = bandName
self.event_name = event_name
self.price = price
self.location = location
self.quantity = quantity
self.event_desc = event_desc
self.event_photo = event_photo
def __repr__(self):
return '<Event %r>' % self.event_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 Merch(db.Model):
__tablename__ = "merch"
merch_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
band_id = db.Column(db.Integer, nullable=False)
bandName = db.Column(db.String(100), nullable =False)
merch_name = db.Column(db.String(100), nullable =False)
price = db.Column(db.Integer, nullable =False)
kategori = db.Column(db.String(100), nullable =False)
quantity = db.Column(db.Integer, nullable =False)
merch_desc = db.Column(db.String(500), nullable =False)
merch_photo = db.Column(db.String(100), nullable =False)
response_field = {
'merch_id': fields.Integer,
'band_id': fields.Integer,
'bandName': fields.String,
'merch_name': fields.String,
'price': fields.Integer,
'kategori': fields.String,
'quantity': fields.Integer,
'merch_desc': fields.String,
'merch_photo': fields.String
}
public_response_field = {
'merch_id': fields.Integer,
'band_id': fields.Integer,
'bandName': fields.String,
'merch_name': fields.String,
'price': fields.Integer,
'kategori': fields.String,
'quantity': fields.Integer,
'merch_desc': fields.String,
'merch_photo': fields.String
}
def __init__(self, merch_id, band_id, bandName, merch_name, price, kategori, quantity, merch_desc, merch_photo):
self.merch_id = merch_id
self.band_id = band_id
self.bandName = bandName
self.merch_name = merch_name
self.price = price
self.kategori = kategori
self.quantity = quantity
self.merch_desc = merch_desc
self.merch_photo = merch_photo
def __repr__(self):
return '<Merch %r>' %self.merch_id
class StrukturOrganisasi(db.Model):
__tablename__ = "struktur_organisasi"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
created_at = db.Column(db.DateTime, nullable=False)
nama_organisasi = db.Column(db.String(100), nullable=False)
induk_organisasi = db.Column(db.String(100), nullable=False)
alamat = db.Column(db.String(100), nullable=True)
kabupaten = db.Column(db.String(100), nullable=False)
kecamatan = db.Column(db.String(100), nullable=False)
desa = db.Column(db.String(100), nullable=False)
no_telepon = db.Column(db.String(100), nullable=True)
email = db.Column(db.String(100), nullable=True)
kontak_person = db.Column(db.String(100), nullable=True)
client_id = db.Column(db.Integer,
db.ForeignKey('clients.id'),
nullable=False)
response_field = {
'id': fields.Integer,
'created_at': fields.DateTime,
'nama_organisasi': fields.String,
'induk_organisasi': fields.String,
'alamat': fields.String,
'kabupaten': fields.String,
'kecamatan': fields.String,
'desa': fields.String,
'no_telepon': fields.String,
'email': fields.String,
'kontak_person': fields.String,
'client_id': fields.String,
}
response_field_organisasi = {
'page': fields.Integer,
'total_page': fields.Integer,
'per_page': fields.Integer
}
def __init__(self, created_at, nama_organisasi, induk_organisasi, alamat,
kabupaten, kecamatan, desa, no_telepon, email, kontak_person,
client_id):
self.created_at = created_at
self.nama_organisasi = nama_organisasi
self.induk_organisasi = induk_organisasi
self.alamat = alamat
self.kabupaten = kabupaten
self.kecamatan = kecamatan
self.desa = desa
self.no_telepon = no_telepon
self.email = email
self.kontak_person = kontak_person
self.client_id = client_id
def __repr__(self):
return '<Struktur Organisasi %r>' % self.id
class Products(db.Model):
__tablename__ = "product"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
seller_id = db.Column(db.Integer,
ForeignKey(Clients.id, ondelete='CASCADE'),
nullable=False)
category_id = db.Column(db.Integer,
ForeignKey(Categories.id, ondelete='CASCADE'),
nullable=False)
subcategory_id = db.Column(db.Integer,
ForeignKey(SubCategories.id,
ondelete='CASCADE'),
nullable=False)
url_image = db.Column(db.String(255))
name = db.Column(db.String(100), nullable=False)
price = db.Column(db.Integer, nullable=False)
stock = db.Column(db.Integer, nullable=False)
promo = db.Column(db.String(10), 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,
'seller_id': fields.Integer,
'category_id': fields.Integer,
'subcategory_id': fields.Integer,
'url_image': fields.String,
'name': fields.String,
'price': fields.Integer,
'stock': fields.Integer,
'promo': fields.String,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, seller_id, category_id, subcategory_id, url_image, name,
price, stock, promo):
self.seller_id = seller_id,
self.category_id = category_id,
self.subcategory_id = subcategory_id,
self.url_image = url_image
self.name = name
self.price = price
self.stock = stock
self.promo = promo
def __repr__(self):
return '<Product %r>' % self.id
class Users(db.Model):
__tablename__ = "Users"
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
unique=True,
nullable=False)
username = db.Column(db.String(255), unique=True, nullable=False)
password = db.Column(db.Text, nullable=False)
status = db.Column(db.String(10), nullable=False)
gender = db.Column(db.String(50))
lokasi = db.Column(db.String(50))
email = db.Column(db.String(50))
# created_at = db.Column(db.DataTime)
# updated_at = db.Column(db.DataTime)
# deleted_at = db.Column(db.DataTime)
respond_field = {
'id': fields.Integer,
'username': fields.String,
# 'password' : fields.String,
'status': fields.String,
'gender': fields.String,
'lokasi': fields.String,
'email': fields.String
# 'created_at' : fields.DataTime,
# 'updated_at' : fields.DataTime,
# 'deleted_at' : fields.DataTime
}
def __init__(self, id, username, password, status, gender, lokasi,
email): # created_at, updated_at, deleted_at
self.id = id
self.username = username
self.password = generate_password_hash(password)
self.status = status
self.gender = gender
self.lokasi = lokasi
self.email = email
# self.created_at = created_at
# self.updated_at = updated_at
# self.deleted_at = deleted_at
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
def __repr__(self):
return '<Users %r>' % self.id
class Product(db.Model):
__tablename__ = "product"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50))
product_type = db.Column(db.String(50))
category = db.Column(db.String(50))
description = db.Column(db.String(1000))
amount = db.Column(db.Integer)
price = db.Column(db.Integer)
posted_at = db.Column(db.String(50))
posted_by = db.Column(db.Integer)
location = db.Column(db.String(50))
status = db.Column(db.String(20))
offer = db.Column(db.Text)
delivery_provided = db.Column(db.String(10))
flag = db.Column(db.String(25))
response_field = {
'id' : fields.Integer,
'name' : fields.String,
'product_type' : fields.String,
'category' : fields.String,
'description' : fields.String,
'amount': fields.Integer,
'constanta': fields.String,
'price': fields.Integer,
'posted_at' : fields.String,
'posted_by': fields.Integer,
'location' : fields.String,
'status' : fields.String,
'offer' : fields.String,
'delivery_provided' : fields.String,
'flag': fields.String
}
def __init__(self, id, name, product_type, category, description, amount, constanta, price, posted_at, posted_by, location, status, offer, delivery_provided, flag):
self.id = id
self.name = name
self.product_type = product_type
self.category = category
self.description = description
self.amount = amount
self.constanta = constanta
self.price = price
self.posted_at = posted_at
self.posted_by = posted_by
self.location = location
self.status = status
self.offer = offer
self.delivery_provided = delivery_provided
self.flag = flag
# super(Product, self).__init__()
def __repr__(self):
return '<Product id %d>' % self.id
class Product(db.Model):
__tablename__ = "product"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(50))
product_type = db.Column(db.String(50))
category = db.Column(db.String(50))
description = db.Column(db.String(1000))
amount = db.Column(db.Integer)
price = db.Column(db.Integer)
posted_at = db.Column(db.String(50))
posted_by = db.Column(db.Integer)
location = db.Column(db.String(50))
# photo = db.Column(db.File)
status = db.Column(db.String(20))
# offer = db.Column(db.ARRAY(db.String), server_default="[]")
# offer = db.ARRAY(db.String), server_default='[]'
offer = db.Column(db.String(2000))
delivery_provided = db.Column(db.String(10))
response_field = {
'id': fields.Integer,
'name': fields.String,
'product_type': fields.String,
'category': fields.String,
'description': fields.String,
'amount': fields.Integer,
'price': fields.Integer,
'posted_at': fields.String,
'posted_by': fields.Integer,
'location': fields.String,
'status': fields.String,
'offer': fields.String,
'delivery_provided': fields.String
}
def __init__(self, id, name, product_type, category, description, amount,
price, posted_at, posted_by, location, status, offer,
delivery_provided):
self.id = id
self.name = name
self.product_type = product_type
self.category = category
self.description = description
self.amount = amount
self.price = price
self.posted_at = posted_at
self.posted_by = posted_by
self.location = location
self.status = status
self.offer = offer
self.delivery_provided = delivery_provided
# super(Product, self).__init__()
def __repr__(self):
return '<Product id %d>' % 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 Driver(db.Model):
__tablename__ = "driver"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
buyer_id = db.Column(db.Integer)
seller_id = db.Column(db.Integer)
product_type = db.Column(db.String(20))
location = db.Column(db.String(20))
destination = db.Column(db.String(20))
amount = db.Column(db.Integer)
price = db.Column(db.Integer)
recomended_vehicle = db.Column(db.String(50))
description = db.Column(db.String(2000))
created_at = db.Column(db.String(50))
expired_at = db.Column(db.String(50))
status = db.Column(db.String(50))
asigned_driver_id = db.Column(db.String(50))
response_field = {
'id': fields.Integer,
'buyer_id': fields.Integer,
'seller_id': fields.Integer,
'product_type': fields.String,
'location': fields.String,
'destination': fields.String,
'amount': fields.Integer,
'price': fields.Integer,
'recomended_vehicle': fields.String,
'description': fields.String,
'created_at': fields.String,
'expired_at': fields.String,
'status': fields.String,
'asigned_driver_id': fields.String
}
def __init__(self, id, buyer_id, seller_id, product_type, location,
destination, amount, price, recomended_vehicle, description,
created_at, expired_at, status, asigned_driver_id):
self.id = id
self.buyer_id = buyer_id
self.seller_id = seller_id
self.product_type = product_type
self.location = location
self.destination = destination
self.amount = amount
self.price = price
self.recomended_vehicle = recomended_vehicle
self.description = description
self.created_at = created_at
self.expired_at = expired_at
self.status = status
self.asigned_driver_id = asigned_driver_id
def __repr__(self):
return '<Driver id %d>' % self.id
class Problems(db.Model):
# Define the property (each property associated with a column in database)
__tablename__ = 'problems'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
level = db.Column(db.String(255), nullable=False, default='')
content = db.Column(db.Text, nullable=False, default='')
problem_type = db.Column(db.String(255), nullable=False, default='')
answer = db.Column(db.Text, nullable=False, default='')
first_option = db.Column(db.Text, default='')
second_option = db.Column(db.Text, default='')
third_option = db.Column(db.Text, default='')
fourth_option = db.Column(db.Text, 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 "Problems" instances into JSON form
response_fields = {
'id': fields.Integer,
'level': fields.String,
'content': fields.String,
'problem_type': fields.String,
'answer': fields.String,
'first_option': fields.String,
'second_option': fields.String,
'third_option': fields.String,
'fourth_option': fields.String,
'created_at': fields.DateTime,
'updated_at': fields.DateTime,
'deleted_at': fields.DateTime
}
# Required fields when create new instances of "Problems" class
def __init__(self, level, content, problem_type, answer, first_option,
second_option, third_option, fourth_option):
self.level = level
self.content = content
self.problem_type = problem_type
self.answer = answer
self.first_option = first_option
self.second_option = second_option
self.third_option = third_option
self.fourth_option = fourth_option
# Reprsentative form to be shown in log
def __repr__(self):
return "Problems ID " + str(self.id) + " (" + self.level + ")"
class BookingRequest(db.Model):
__tablename__ = 'booking request'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
id_user = db.Column(db.Integer)
sport = db.Column(db.String(50), nullable=False)
player = db.Column(db.Integer, nullable=False)
time = db.Column(db.String(50), nullable=False)
location = db.Column(db.Text, nullable=False)
compound = db.Column(db.Text)
vicinity = db.Column(db.Text)
status = db.Column(db.String(50))
url_image = db.Column(db.String(1000))
pemain_saat_ini = db.Column(db.Integer)
harga = db.Column(db.Integer)
response_field = {
'id': fields.Integer,
'id_user': fields.Integer,
'sport': fields.String,
'player': fields.Integer,
'time': fields.String,
'location': fields.String,
'compound': fields.String,
'vicinity': fields.String,
'status': fields.String,
'url_image': fields.String,
'pemain_saat_ini': fields.Integer,
'harga': fields.Integer,
}
def __init__(self, id, id_user, sport, player, time, location, compound,
vicinity, status, url_image, pemain_saat_ini, harga):
self.id = id
self.id_user = id_user
self.sport = sport
self.player = player
self.time = time
self.location = location
self.compound = compound
self.vicinity = vicinity
self.status = status
self.url_image = url_image
self.pemain_saat_ini = pemain_saat_ini
self.harga = harga
def __repr__(self):
return '<Booking Request %r>' % self.id
class Outlets(db.Model):
__tablename__ = 'outlets'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
id_user = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
name = db.Column(db.String(150), nullable=False, default='')
phone_number = db.Column(db.String(20), nullable=False, default='')
address = db.Column(db.String(150), nullable=False, default='')
city = db.Column(db.String(150), nullable=False, default='')
tax = db.Column(db.Integer, nullable=False, default=0)
created_at = db.Column(
db.DateTime,
default=(datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S"))
updated_at = db.Column(
db.DateTime,
default=(datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S"))
deleted = db.Column(db.Boolean, default=False)
response_fields = {
'id': fields.Integer,
'id_user': fields.Integer,
'name': fields.String,
'phone_number': fields.String,
'address': fields.String,
'city': fields.String,
'tax': fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime,
'deleted': fields.Boolean
}
jwt_claim_fields = {'id': fields.Integer, 'deleted': fields.Boolean}
def __init__(self, id_user, name, phone_number, address, city, tax):
self.id_user = id_user
self.name = name
self.phone_number = phone_number
self.address = address
self.city = city
self.tax = tax
self.created_at = (datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S")
self.updated_at = (datetime.now() +
timedelta(hours=7)).strftime("%Y-%m-%d %H:%M:%S")
self.deleted = False
def __repr__(self):
return '<Outlets %r>' % self.name
class Timedetails(db.Model):
__tablename__ = "timedetails"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
time_trxid = db.Column(db.Integer,
db.ForeignKey('transactions.id',
ondelete='CASCADE'),
nullable=False)
time_userid = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
year = db.Column(db.Integer, nullable=False, default=None)
month = db.Column(db.Integer, nullable=False, default=None)
date = db.Column(db.Integer, nullable=False, default=None)
month_char = db.Column(db.String(15), default=None)
date_char = db.Column(db.String(10), default=None)
class Articles(db.Model):
__tablename__ = "articles"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
title = db.Column(db.String(255), nullable=False, default="")
text = db.Column(db.Text, default="")
image = db.Column(db.String(255), default="")
image_caption = db.Column(db.String(255), default="")
topic = db.Column(db.Integer, db.ForeignKey('article_topics.id'))
created_at = db.Column(db.DateTime(timezone=True),
server_default=func.now())
updated_at = db.Column(db.DateTime(timezone=True), onupdate=func.now())
published = db.Column(db.Boolean, default=False)
popular = db.Column(db.Boolean, default=False)
top_article = db.Column(db.Boolean, default=False)
editors_pick = db.Column(db.Boolean, default=False)
response_fields = {
"id": fields.Integer,
"user_id": fields.Integer,
"title": fields.String,
"text": fields.String,
"image": fields.String,
"image_caption": fields.String,
"topic": fields.String,
"created_at": fields.DateTime,
"updated_at": fields.DateTime,
"published": fields.Boolean,
"popular": fields.Boolean,
"top_article": fields.Boolean,
"editors_pick": fields.Boolean,
}
def __init__(self, user_id, title, text, image, image_caption, topic,
published, popular, top_article, editors_pick):
self.user_id = user_id
self.title = title
self.text = text
self.image = image
self.image_caption = image_caption
self.topic = topic
self.published = published
self.popular = popular
self.top_article = top_article
self.editors_pick = editors_pick
def __repr__(self):
return "<Articles %r>" % self.id
class TopLevels(db.Model):
__tablename__ = "top_level"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = user_id = db.Column(db.Integer,
db.ForeignKey('user.user_id'),
nullable=False)
title = db.Column(db.String(255), nullable=False)
#content type -- either article or question
content_type = db.Column(db.String(30), nullable=False)
html_content = db.Column(db.Text, nullable=False)
banner_photo_url = db.Column(db.String(255))
views = db.Column(db.Integer, nullable=False)
#status should merged into one? 0 - normal, 1 - closed, 2 - deleted?
# deleted = db.Column(db.Boolean, nullable=False)
# closed = db.Column(db.Boolean, nullable=False)
content_status = db.Column(db.SmallInteger, nullable=False)
point = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, server_default=db.func.now())
updated_at = db.Column(db.DateTime, server_onupdate=db.func.now())
#sementara, html_content di output dalam bentuk string
response_fields = {
'id': fields.Integer,
'user_id': fields.Integer,
'title': fields.String,
'content_type': fields.String,
'html_content': fields.String,
'banner_photo_url': fields.String,
'views': fields.Integer,
'content_status': fields.Integer,
'point': fields.Integer,
'created_at': fields.String,
'updated_at': fields.String
}
def __init__(self, user_id, title, content_type, html_content, **kwargs):
self.user_id = user_id
self.title = title
self.content_type = content_type
self.html_content = html_content
self.views = 0
self.content_status = 0
self.point = 0
if 'banner_photo_url' in kwargs:
self.banner_photo_url = kwargs.get("banner_photo_url")
def __repr__(self):
return '<Top Level %r>' % self.title
class Items(db.Model):
__tablename__ = "items"
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
unique=True)
nama = db.Column(db.String(200))
merek = db.Column(db.String(200))
kategori = db.Column(db.String(200))
detail = db.Column(db.String(500))
harga = db.Column(db.Integer)
stock = db.Column(db.Integer)
url_picture = db.Column(db.String(200))
user_id = db.Column(db.Integer)
created_at = db.Column(db.DateTime, nullable=False)
updated_at = db.Column(db.DateTime, nullable=False)
respon_fields = {
'id': fields.Integer,
'nama': fields.String,
'merek': fields.String,
'kategori': fields.String,
'detail': fields.String,
'harga': fields.Integer,
'stock': fields.Integer,
'url_picture': fields.String,
'user_id': fields.Integer,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, id, nama, merek, kategori, detail, harga, stock,
url_picture, user_id, created_at, updated_at):
self.id = id
self.nama = nama
self.merek = merek
self.kategori = kategori
self.detail = detail
self.harga = harga
self.stock = stock
self.url_picture = url_picture
self.user_id = user_id
self.created_at = created_at
self.updated_at = updated_at
#return repr harus string
def __repr__(self):
return '<Item %r>' % self.id
class Cart(db.Model):
__tablename__ = "cart"
id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
unique=True)
transaction_id = db.Column(db.Integer)
item_id = db.Column(db.Integer)
nama_item = db.Column(db.String(200))
url_picture = db.Column(db.String(200))
qty = db.Column(db.Integer)
harga = db.Column(db.Integer)
customer_id = db.Column(db.Integer)
status = db.Column(db.String(200))
created_at = db.Column(db.DateTime, nullable=False)
updated_at = db.Column(db.DateTime, nullable=False)
respon_fields = {
'id': fields.Integer,
'transaction_id': fields.Integer,
'item_id': fields.Integer,
'nama_item': fields.String,
'url_picture': fields.String,
'qty': fields.Integer,
'harga': fields.Integer,
'customer_id': fields.Integer,
'status': fields.String,
'created_at': fields.DateTime,
'updated_at': fields.DateTime
}
def __init__(self, id, transaction_id, item_id, nama_item, url_picture,
qty, harga, customer_id, status, created_at, updated_at):
self.id = id
self.transaction_id = transaction_id
self.item_id = item_id
self.nama_item = nama_item
self.url_picture = url_picture
self.qty = qty
self.harga = harga
self.customer_id = customer_id
self.status = status
self.created_at = created_at
self.updated_at = updated_at
#return repr harus string
def __repr__(self):
return '<Cart %r>' % self.id
