Example #1
0
class DistanceModel(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    city_1 = db.Column(db.String(100))
    city_2 = db.Column(db.String(100))
    distance = db.Column(db.Integer)
    __table_args__ = db.UniqueConstraint('city_1',
                                         'city_2',
                                         name='_city_1_city_2'),

    @classmethod
    def get_distance(cls, point_1, point_2):
        distance = db.session.query(cls).filter_by(city_1=point_1,
                                                   city_2=point_2).first()
        if not distance:
            distance = db.session.query(cls).filter_by(city_1=point_2,
                                                       city_2=point_1).first()
        return distance.distance if distance else None

    @classmethod
    def create_object(cls, city_1, city_2, distance):
        distance_object = cls(city_1=city_1, city_2=city_2, distance=distance)
        db.session.add(distance_object)
        db.session.commit()

    def __repr__(self):
        return f"Distance({self.city_1} and {self.city_2} = {self.distance})"
Example #2
0
class User(db.Model, UserMixin):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)

    # User Authentication information
    username = db.Column(db.String(50), nullable=False, unique=True)
    password = db.Column(db.String(255), nullable=False, default='')

    # User Email information
    email = db.Column(db.String(255), nullable=False, unique=True)
    email_confirmed_at = db.Column(db.DateTime())

    # User information
    is_enabled = db.Column(db.Boolean(), nullable=False, default=True)
    trash = db.Column(db.Boolean, nullable=False, default=False)
    roles = db.relationship('Role', secondary='users_roles')

    def is_active(self):
        return self.is_enabled

    def save(self):
        db.session.add(self)
        db.session.commit()

    @staticmethod
    def get_by_id(user_id):
        return User.query.get(user_id)

    def remove(self):
        self.trash = True
        db.session.add(self)
        db.session.commit()

    def delete(self):
        db.session.delete(self)
        db.session.commit()

    def restore(self):
        self.trash = False
        db.session.add(self)
        db.session.commit()

    @staticmethod
    def get_username(username):
        return User.query.filter(User.username == username).first()

    def create_password(self, password):
        self.password = str(
            sha256(
                str(md5(str(password).encode('utf-8')).hexdigest()).encode(
                    'utf-8')).hexdigest())

    def check_password(self, password):
        return self.password == str(
            sha256(
                str(md5(str(password).encode('utf-8')).hexdigest()).encode(
                    'utf-8')).hexdigest())
Example #3
0
class Photo(db.Model):
    __tablename__ = 'photo'
    id = db.Column(db.Integer, primary_key=True)
    filename = db.Column(db.String(200))
    alt = db.Column(db.String(200))
    trash = db.Column(db.Boolean, default=0, nullable=False)
    create_at = db.Column(db.DateTime, default=func.current_timestamp())
    update_at = db.Column(db.DateTime, onupdate=func.now())
    delete_at = db.Column(db.DateTime)
Example #4
0
class Alamat(db.Model):
    __tablename__ = 'tb_alamat'
    id = db.Column(db.Integer, primary_key=True)
    id_dusun = db.Column(db.Integer,
                         db.ForeignKey('tb_dusun.id', ondelete='cascade'))
    dusun = db.relationship('Dusun',
                            foreign_keys=id_dusun,
                            backref=db.backref('dusun_alamat'))
    rt_rw = db.Column(db.String(10))
    kode_pos = db.Column(db.String(5))

    @staticmethod
    def get_by_id(id_alamat):
        return Alamat.query.get(id_alamat)

    def desa(self):
        if self.dusun:
            return self.dusun.desa
        return None

    def kec(self):
        if self.dusun and self.dusun.desa:
            return self.dusun.desa.kec
        return None

    def kab(self):
        if self.dusun and self.dusun.desa and self.dusun.desa.kec:
            return self.dusun.desa.kec.kab
        return None

    def prov(self):
        if self.dusun and self.dusun.desa \
            and self.dusun.desa.kec \
                and self.dusun.desa.kec.kab:
            return self.dusun.desa.kec.kab.prov
        return None

    def get_all(search='', page=1):
        return Alamat.query.join(Dusun, Alamat.id_dusun == Dusun.id).join(
            Desa,
            Dusun.id_desa == Desa.id).join(Kec, Desa.id_kec == Kec.id).filter(
                or_(Dusun.nama.like('%{}%'.format(search)),
                    Desa.nama.like('%{}%'.format(search)),
                    Kec.nama.like('%{}%'.format(search)))).paginate(
                        page, per_page=10)

    def save(self):
        db.session.add(self)
        db.session.commit()
Example #5
0
class User(db.Model, UserMixin):
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(255), nullable=False, server_default=u'', unique=True)
    # User authentication information (required for Flask-User)
    email = db.Column(db.Unicode(255), nullable=False, server_default=u'', unique=True)
    email_confirmed_at = db.Column(db.DateTime())
    password = db.Column(db.String(255), nullable=False, server_default='')
    # reset_password_token = db.Column(db.String(100), nullable=False, server_default='')
    active = db.Column(db.Boolean(), nullable=False, server_default='0')

    # User information
    active = db.Column('is_active', db.Boolean(), nullable=False, server_default='0')
    first_name = db.Column(db.Unicode(50), nullable=False, server_default=u'')
    last_name = db.Column(db.Unicode(50), nullable=False, server_default=u'')

    # Relationships
    roles = db.relationship('Role', secondary='users_roles',
                            backref=db.backref('users', lazy='dynamic'))
    
    @staticmethod
    def get_by_id(user_id):
        return User.query.get(user_id)
    
    @staticmethod
    def get_by_username(username):
        return User.query.filter(User.username==username).first()
    
    def generate_password(self, password):
        self.password = sha256(
            str(
                md5(
                    str(password).encode('utf-8')
                ).hexdigest()
            ).encode('utf-8')
        ).hexdigest()
    
    def check_password(self, password):
        return self.password == sha256(
            str(
                md5(
                    str(password).encode('utf-8')
                ).hexdigest()
            ).encode('utf-8')
        ).hexdigest()
Example #6
0
class Keluarga(db.Model):
    __tablename__ = 'tb_keluarga'

    id = db.Column(db.Integer, primary_key=True)
    no_kk = db.Column(db.String(45))
    nama_kk = db.Column(db.String(45))
    id_alamat = db.Column(db.Integer,
                          db.ForeignKey('tb_alamat.id', ondelete='cascade'))
    alamat = db.relationship('Alamat',
                             foreign_keys=id_alamat,
                             backref=db.backref('keluarga_alamat'))

    @staticmethod
    def get_all(page=1, search=''):
        return Keluarga.query.filter(
            or_(Keluarga.nama_kk.like('%{}%'.format(search)),
                Keluarga.no_kk.like('%{}%'.format(search)))).paginate(
                    page, per_page=10)
Example #7
0
class Location(db.Model):
    __tablename__ = 'location'
    id = db.Column(db.Integer, primary_key=True)
    village = db.Column(db.String(200))
    district = db.Column(db.String(200))
    lat = db.Column(db.Float)
    lng = db.Column(db.Float)
    address = db.Column(db.Text)
    trash = db.Column(db.Boolean, default=0, nullable=False)
    create_at = db.Column(db.DateTime, default=func.current_timestamp())
    update_at = db.Column(db.DateTime, onupdate=func.now())
    delete_at = db.Column(db.DateTime)

    def location_form(self, form):
        self.village = form.village.data
        self.district = form.district.data
        self.address = form.address_loc.data
        self.lat = form.lat.data
        self.lng = form.lng.data
Example #8
0
class Administrator(db.Model):
    __tablename__ = 'administrator'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(200))
    first_name = db.Column(db.String(200))
    last_name = db.Column(db.String(200))
    desc = db.Column(db.Text)
    contact = db.Column(db.String(45))
    address = db.Column(db.Text)
    trash = db.Column(db.Boolean, default=0, nullable=False)
    create_at = db.Column(db.DateTime, default=func.current_timestamp())
    update_at = db.Column(db.DateTime, onupdate=func.now())
    delete_at = db.Column(db.DateTime)

    def admin_form(self, form):
        self.name = form.admin_name.data
        self.first_name = form.first_name.data
        self.last_name = form.last_name.data
        self.contact = form.contact.data
        self.address = form.address_admin.data
Example #9
0
class Role(db.Model):
    __tablename__ = 'roles'
    id = db.Column(db.Integer(), primary_key=True)
    name = db.Column(db.String(50),
                     nullable=False,
                     server_default=u'',
                     unique=True)  # for @roles_accepted()
    desc = db.Column(db.Text)  # for display purposes

    def save(self):
        db.session.add(self)
        db.session.commit()
Example #10
0
class Feature(db.Model):
    __tablename__ = 'feature'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(200))
    count_feature = db.Column(db.Integer)
    desc = db.Column(db.Text)
    trash = db.Column(db.Boolean, default=0, nullable=False)
    photos = db.relationship('Photo',
                             secondary='photo_feature_wisata',
                             backref=db.backref('feature', lazy='dynamic'))
    create_at = db.Column(db.DateTime, default=func.current_timestamp())
    update_at = db.Column(db.DateTime, onupdate=func.now())
    delete_at = db.Column(db.DateTime)
Example #11
0
class Dusun(db.Model):
    __tablename__ = 'tb_dusun'
    id = db.Column(db.Integer, primary_key=True)
    nama = db.Column(db.String(45))
    id_desa = db.Column(db.Integer,
                        db.ForeignKey('tb_desa.id', ondelete='cascade'))
    desa = db.relationship('Desa',
                           foreign_keys=id_desa,
                           backref=db.backref('desa_dusun'))

    @staticmethod
    def get_by_desa(desa_id, search=''):
        return Dusun.query.filter(
            and_(Dusun.id_desa == desa_id,
                 or_(Dusun.nama.like('%{}%'.format(search))))).all()
Example #12
0
class Desa(db.Model):
    __tablename__ = 'tb_desa'
    id = db.Column(db.Integer, primary_key=True)
    nama = db.Column(db.String(45))
    id_kec = db.Column(db.Integer,
                       db.ForeignKey('tb_kec.id', ondelete='cascade'))
    kec = db.relationship('Kec',
                          foreign_keys=id_kec,
                          backref=db.backref('kec_desa'))

    @staticmethod
    def get_by_kec(kec_id, search=''):
        return Desa.query.filter(
            and_(Desa.id_kec == kec_id,
                 or_(Desa.nama.like('%{}%'.format(search))))).all()
Example #13
0
class Kec(db.Model):
    __tablename__ = 'tb_kec'
    id = db.Column(db.Integer, primary_key=True)
    nama = db.Column(db.String(45))
    id_kab = db.Column(db.Integer,
                       db.ForeignKey('tb_kab.id', ondelete='cascade'))
    kab = db.relationship('Kab',
                          foreign_keys=id_kab,
                          backref=db.backref('kab_kec'))

    @staticmethod
    def get_by_kab(kab_id, search=''):
        return Kec.query.filter(
            and_(Kec.id_kab == kab_id,
                 or_(Kec.nama.like('%{}%'.format(search))))).all()
Example #14
0
class Kab(db.Model):
    __tablename__ = 'tb_kab'
    id = db.Column(db.Integer, primary_key=True)
    nama = db.Column(db.String(45))
    id_prov = db.Column(db.Integer,
                        db.ForeignKey('tb_prov.id', ondelete='cascade'))
    prov = db.relationship('Provinsi',
                           foreign_keys=id_prov,
                           backref=db.backref('prov_kab'))

    @staticmethod
    def get_by_prov(prov_id, search=''):
        return Kab.query.filter(
            and_(Kab.id_prov == prov_id,
                 or_(Kab.nama.like('%{}%'.format(search))))).all()
Example #15
0
class Wisata(db.Model):
    __tablename__ = 'wisata'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(200))
    desc = db.Column(db.Text)
    features = db.relationship('Feature',
                               secondary='features_wisata',
                               backref=db.backref('wisata', lazy='dynamic'))
    location_id = db.Column(db.Integer,
                            db.ForeignKey('location.id', ondelete='CASCADE'))
    location = db.relationship('Location',
                               foreign_keys=location_id,
                               backref=db.backref('location_wisata'))
    admin_id = db.Column(db.Integer,
                         db.ForeignKey('administrator.id', ondelete='CASCADE'))
    admin = db.relationship('Administrator',
                            foreign_keys=admin_id,
                            backref=db.backref('administrator_wisata'))
    trash = db.Column(db.Boolean, default=0, nullable=False)
    photos = db.relationship('Photo',
                             secondary='photo_wisata',
                             backref=db.backref('wisata', lazy='dynamic'))
    create_at = db.Column(db.DateTime, default=func.current_timestamp())
    update_at = db.Column(db.DateTime, onupdate=func.now())
    delete_at = db.Column(db.DateTime)

    @staticmethod
    def get_all_data(search="", page=1, perpage=15):
        return Wisata.query.filter(Wisata.name.like(
            '%{}%'.format(search))).paginate(page, perpage, False)

    @staticmethod
    def get_by_id(wisata_id):
        return Wisata.query.get(wisata_id)

    def wisata_form(self, form):
        self.name = form.name.data
        self.desc = form.desc.data

    def save(self):
        db.session.add(self)
        db.session.commit()
Example #16
0
class Provinsi(db.Model):
    __tablename__ = 'tb_prov'
    id = db.Column(db.Integer, primary_key=True)
    nama = db.Column(db.String(45))
Example #17
0
class Role(db.Model):
    __tablename__ = 'roles'
    id = db.Column(db.Integer(), primary_key=True)
    name = db.Column(db.String(50), nullable=False, server_default=u'', unique=True)  # for @roles_accepted()
    label = db.Column(db.Unicode(255), server_default=u'')  # for display purposes