Beispiel #1
0
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
Beispiel #2
0
class Users(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(30), unique=True, nullable=False)
    age = db.Column(db.Integer, nullable=True, default=20)
    sex = db.Column(db.String(10), 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())
    deleted_at = db.Column(db.DateTime)
    client_id = db.Column(db.Integer, db.ForeignKey('client.id'))
 

    response_field = {
        'created_at':fields.DateTime,
        'updated_at':fields.DateTime,
        'deleted_at':fields.DateTime,
        'id':fields.Integer,
        'name': fields.String,
        'age': fields.Integer,
        'sex': fields.String,
        "client_id": fields.Integer,
    }

    def __init__(self, name, age, sex,client_id):
        self.name = name
        self.age = age
        self.sex = sex
        self.client_id = client_id

    def __repr__(self):
        return '<User %r>' % self.id
Beispiel #3
0
class Shipping(db.Model):
    __tablename__ = "shipping"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    transaction_id = db.Column(db.Integer, ForeignKey(Transaction.id, ondelete='CASCADE'), nullable=False)
    origin = db.Column(db.Integer, nullable=False)
    destination = db.Column(db.Integer, nullable=False)
    weight = db.Column(db.Integer, nullable=False)
    fee = db.Column(db.Numeric(12,2), nullable=False)
    shipping_number = db.Column(db.String(100), 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,
        'transaction_id' : fields.Integer,
        'origin' : fields.String,
        'destination' :fields.String,
        'weight' :fields.Integer,
        'fee' : fields.Integer,
        'shipping_number' : fields.String,
        'created_at' : fields.String,
        'updated_at' : fields.String
    }

    def __init__(self, transaction_id, origin, destination, weight, fee, shipping_number):
        self.transaction_id = transaction_id
        self.origin = origin
        self.destination = destination
        self.weight = weight
        self.fee = fee
        self.shipping_number = shipping_number
        
    def __repr__(self):
        return '<Shipping %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
Beispiel #5
0
class Clients(db.Model):
    __tablename__ = "client"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    username = db.Column(db.String(100), nullable=False, unique=True)
    password = db.Column(db.String(255))
    salt = db.Column(db.String(255))
    status = db.Column(db.Boolean, nullable=True, default=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': fields.Boolean,
        'created_at': fields.DateTime,
        'updated_at': fields.DateTime
    }

    jwt_claims_fields = {
        'id': fields.Integer,
        'username': fields.String,
        'status': fields.Boolean
    }

    def __init__(self, username, password, status, salt):
        self.username = username
        self.password = password
        self.status = status
        self.salt = salt

    def __repr__(self):
        return '<Client %r>' % self.id
Beispiel #6
0
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
Beispiel #7
0
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
Beispiel #8
0
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
Beispiel #9
0
class Transaksis(db.Model):
    __tablename__ = "transaksi"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    pembeli = db.Column(db.String(1000), nullable=False)
    produk = db.Column(db.String(1000), nullable=False)
    total_harga = db.Column(db.Integer)
    total_barang = db.Column(db.Integer)
    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,
        'pembeli': fields.String,
        'produk': fields.String,
        'total_harga': fields.Integer,
        'total_barang': fields.Integer,
        'created_at': fields.DateTime,
        'updated_at': fields.DateTime
    }

    def __init__(self, pembeli, produk, total_harga, total_barang):
        self.pembeli = pembeli
        self.produk = produk
        self.total_harga = total_harga
        self.total_barang = total_barang

    def __repr__(self):
        return '<Transaksi %r>' % self.id
Beispiel #10
0
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 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
Beispiel #12
0
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
Beispiel #14
0
class TransactionDetailModel(db.Model):
    __tablename__ = "transaction_details"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    harga = db.Column(db.Integer, default=0)
    kuantitas = db.Column(db.Integer, default=0)
    cart_id = db.Column(db.Integer, db.ForeignKey('carts.id'))
    product_id = db.Column(db.Integer, db.ForeignKey('products.id'))
    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,
        'harga': fields.Integer,
        'kuantitas': fields.Integer,
        'cart_id': fields.Integer,
        'product_id': fields.Integer,
    }

    def __init__(self, harga, kuantitas, cart_id, product_id):
        self.harga = harga
        self.kuantitas = kuantitas
        self.cart_id = cart_id
        self.product_id = product_id

    def __repr__(self):
        return '<TransactionDetails %r>' % self.id
class ChoicesQuiz(db.Model):
    __tablename__ = "choices_quiz"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    question_id = db.Column(db.Integer,
                            db.ForeignKey(QuestionsQuiz.id,
                                          ondelete="CASCADE"),
                            nullable=False)
    choice = db.Column(db.Text, nullable=False)
    is_correct = db.Column(db.Boolean)
    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())

    response_fields = {
        "id": fields.Integer,
        "question_id": fields.Integer,
        "choice": fields.String,
        "is_correct": fields.Boolean,
        "status": fields.Boolean,
        "created_at": fields.DateTime,
        "update_at": fields.DateTime,
    }

    def __init__(self, question_id, choice, is_correct, status):
        self.question_id = question_id
        self.choice = choice
        self.is_correct = is_correct
        self.status = status

    def __rpr__(self):
        return "<Questions %r>" % self.id
Beispiel #16
0
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
Beispiel #17
0
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
Beispiel #18
0
class Komens(db.Model):
    __tablename__ = "komen"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    komen = db.Column(db.String(255), nullable=True, default='Title Image')
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    image_id = db.Column(db.Integer, db.ForeignKey('image.id'))
    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,
        'komen': fields.String,
        'created_at': fields.DateTime,
        'updated_at': fields.DateTime,
        'user_id': fields.Integer,
        'image_id': fields.Integer
    }

    def __init__(self, komen, user_id, image_id):
        self.komen = komen
        self.user_id = user_id
        self.image_id = image_id

    def __repr__(self):
        return '<Komen %r>' % self.id
class ReviewsModule(db.Model):
    __tablename__ = "reviews_module"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    mentee_id = db.Column(db.Integer, db.ForeignKey(Mentees.id, ondelete="CASCADE"), nullable=False)
    module_id = db.Column(db.Integer, db.ForeignKey(Modules.id, ondelete="CASCADE"), nullable=False)
    content = db.Column(db.Text)
    score = 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())

    response_fields = {
        "id": fields.Integer,
        "mentee_id": fields.Integer,
        "module_id": fields.Integer,
        "content": fields.String,
        "score": fields.Integer,
        "status": fields.Boolean,
        "created_at": fields.DateTime,
        "update_at": fields.DateTime
    }

    def __init__ (self, mentee_id, module_id, content, score, status):
        self.mentee_id = mentee_id
        self.module_id = module_id
        self.content = content
        self.score = score
        self.status = status

    def __rpr__(self):
        return "<Users %r>" % self.id
Beispiel #20
0
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
Beispiel #21
0
class HistoriesExam(db.Model):
    __tablename__ = "histories_exam"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    exam_id = db.Column(db.Integer,
                        db.ForeignKey(Exams.id, ondelete="CASCADE"),
                        nullable=False)
    mentee_id = db.Column(db.Integer,
                          db.ForeignKey(Mentees.id, ondelete="CASCADE"),
                          nullable=False)
    score = 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())

    response_fields = {
        "id": fields.Integer,
        "exam_id": fields.Integer,
        "mentee_id": fields.Integer,
        "score": fields.Integer,
        "status": fields.Boolean,
        "created_at": fields.DateTime,
        "update_at": fields.DateTime
    }

    def __init__(self, exam_id, mentee_id, score, status):
        self.exam_id = exam_id
        self.mentee_id = mentee_id
        self.score = score
        self.status = status

    def __rpr__(self):
        return "<Users %r>" % self.id
Beispiel #22
0
class ReviewProduk(db.Model):
    __tablename__ = "table_review_produk"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    gambar = db.Column(db.String(255))
    review = db.Column(db.String(255), 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())
    transaction_detail_id = db.Column(db.Integer,
                                      db.ForeignKey('transaction_detail.id'))

    response_fields = {
        'id': fields.Integer,
        'gambar': fields.String,
        'review': fields.String,
        'created_at': fields.DateTime,
        'updated_at': fields.DateTime,
        'transaction_detail_id': fields.Integer
    }

    def __init__(self, gambar, review):
        self.gambar = gambar
        self.review = review

    def __repr__(self):
        return '<ReviewProduk %r>' % self.id
Beispiel #23
0
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
Beispiel #24
0
class Bios(db.Model):
	__tablename__ = "bio"
	id = db.Column(db.Integer, primary_key=True, autoincrement=True)
	fullname = db.Column(db.String(100), nullable=False)
	address = db.Column(db.Text, nullable=False)
	contact = db.Column(db.String(15), nullable=False)
	sex = db.Column(db.String(1), nullable=True)
	user_id = db.Column(db.Integer, ForeignKey(Users.id, ondelete='CASCADE'), unique=True, 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,
		'fullname' : fields.String,
		'address' : fields.String,
		'contact' : fields.String,
		'sex' : fields.String,
		'user_id' : fields.Integer,
		'created_at' : fields.String,
		'updated_at' : fields.String
	}

	def __init__(self, fullname, address, contact, sex, user_id):
		self.fullname = fullname
		self.address = address
		self.contact = contact
		self.sex = sex
		self.user_id = user_id

	def __repr__(self):
		return '<Bio %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 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
Beispiel #27
0
class ProductImg(db.Model):
    __tablename__ = "product_img"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    img_path = db.Column(db.Text, nullable=False)
    img_desc = db.Column(db.Text, 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,
        'img_path': fields.String,
        'img_desc': fields.String,
        'product_id': fields.Integer,
        'created_at': fields.String,
        'updated_at': fields.String
    }

    def __init__(self, img_path, img_desc, product_id):
        self.img_path = img_path
        self.img_desc = img_desc
        self.product_id = product_id

    def __repr__(self):
        return '<ProductImg %r>' % self.id
class DetailsAltatest(db.Model):
    __tablename__ = "details_altatest"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    altatest_id = db.Column(db.Integer, db.ForeignKey(Altatests.id, ondelete="CASCADE"), nullable=False)
    question_id = db.Column(db.Integer, db.ForeignKey(QuestionsAltatest.id, ondelete="CASCADE"), 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())

    response_fields = {
        "id": fields.Integer,
        "altatest_id": fields.Integer,
        "question_id": fields.Integer,
        "status": fields.Boolean,
        "created_at": fields.DateTime,
        "updated_at": fields.DateTime
    }

    def __init__ (self, altatest_id, question_id,status):
        self.altatest_id = altatest_id
        self.question_id = question_id
        self.status = status

    def __rpr__(self):
        return "<Users %r>" % self.id
Beispiel #29
0
class Livecodes(db.Model):
    __tablename__ = "livecodes"
    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)
    link = db.Column(db.String(250))
    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())

    response_fields = {
        "id": fields.Integer,
        "exam_id": fields.Integer,
        "name": fields.String,
        "description": fields.String,
        "link": fields.String,
        "status": fields.Boolean,
        "created_at": fields.DateTime,
        "update_at": fields.DateTime,
    }

    def __init__(self, exam_id, name, description, link, status):
        self.exam_id = exam_id
        self.name = name
        self.description = description
        self.link = link
        self.status = status

    def __rpr__(self):
        return "<Questions %r>" % self.id
Beispiel #30
0
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